@wrongstack/cli 1.0.19 → 1.0.26

package/dist/chunk-SFBFYIOW.js

@@ -0,0 +1,271 @@
+import {
+  appendHistory,
+  backupCurrent
+} from "./chunk-WSTVGC2C.js";
+
+// src/settings-menu.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { decryptConfigSecretsForRewrite, encryptConfigSecrets } from "@wrongstack/core/security";
+import { ConfigError, ERROR_CODES, FsError } from "@wrongstack/core/types";
+import { atomicWrite, deepMerge, withFileLock } from "@wrongstack/core/utils";
+function resolvePersistPath(deps) {
+  if (deps.forceGlobal) return deps.profileConfigPath;
+  const scope = deps.configStore.get().configScope;
+  if (scope === "project" && deps.inProjectConfigPath) {
+    return deps.inProjectConfigPath;
+  }
+  return deps.profileConfigPath;
+}
+function resolveActualTarget(deps, decrypted, fallbackPath) {
+  if (deps.forceGlobal) return deps.profileConfigPath;
+  const newScope = decrypted.configScope;
+  const newProfileName = decrypted.activeProfile;
+  const effectiveProfilePath = newProfileName && deps.resolveProfilePath ? deps.resolveProfilePath(newProfileName) : deps.profileConfigPath;
+  if (newScope === "project" && deps.inProjectConfigPath) {
+    return deps.inProjectConfigPath;
+  }
+  if (newScope === "global") {
+    return effectiveProfilePath;
+  }
+  return fallbackPath;
+}
+function isProfileOrGlobalTarget(actualTarget, deps) {
+  return !deps.inProjectConfigPath || path.resolve(actualTarget) !== path.resolve(deps.inProjectConfigPath);
+}
+async function ensureProjectDir(filePath) {
+  const dir = path.dirname(filePath);
+  try {
+    await fs.mkdir(dir, { recursive: true });
+  } catch {
+  }
+}
+var PROJECT_SAFE_FIELDS = /* @__PURE__ */ new Set([
+  "version",
+  "model",
+  "cwd",
+  "fallbackModels",
+  "fallbackBridge",
+  // Kept in sync with core's IN_PROJECT_ALLOWED_KEYS (config-loader.ts): these
+  // model-routing prefs are explicitly safe to READ from a per-project config,
+  // so the writer must not strip them — otherwise a scope=project /fallback
+  // profile/fav write (or a TUI full-config write under project scope) would be
+  // silently dropped while the loader would happily accept them on next boot.
+  "fallbackProfiles",
+  "fallbackProfile",
+  "favoriteModels",
+  "disabledModels",
+  "favoriteModelsOnly",
+  "modelAvailabilitySchedule",
+  "fallbackAuto",
+  "fallbackStickiness",
+  "fallbackGateSeconds",
+  "models",
+  "modelMatrix",
+  "modelTiers",
+  "maxConcurrent",
+  "autonomy",
+  "hints",
+  "nextPrediction",
+  "debugStream",
+  "configScope",
+  "features",
+  "context",
+  "log",
+  "session",
+  "indexing",
+  "tools",
+  "launch",
+  "circuitBreaker",
+  "adaptiveConcurrency",
+  "modelRuntime",
+  "Sage",
+  "skills",
+  "chronicle",
+  "uiLocale",
+  "themePreset"
+]);
+var PROJECT_DENIED_PATHS = [
+  "tools.exec.allow",
+  "tools.exec.danger",
+  "tools.council",
+  "skills.extraDirs",
+  "skills.registryUrl",
+  "skills.suggest",
+  "Sage.storage.directory",
+  "autonomy.yolo",
+  "autonomy.defaultMode",
+  "autonomy.yoloConfirm",
+  "launch.autonomy",
+  "features.allowOutsideProjectRoot",
+  "tools.restrictToProjectRoot",
+  "tools.loopDetection",
+  "tools.maxIterations",
+  "tools.autoExtendLimit",
+  "tools.maxAutoExtensions",
+  "tools.kanbanGovernance",
+  "tools.autoThin",
+  "tools.disabledToolMeta",
+  "tools.wrongProxy",
+  "features.mailboxBridge",
+  "features.pluginsTrust"
+];
+function deleteProjectDeniedPath(target, dotted) {
+  const parts = dotted.split(".");
+  const leaf = parts.pop();
+  if (!leaf) return;
+  let cursor = target;
+  for (const part of parts) {
+    const next = cursor[part];
+    if (!next || typeof next !== "object" || Array.isArray(next)) return;
+    cursor = next;
+  }
+  delete cursor[leaf];
+}
+function filterSafeForProject(cfg) {
+  const out = {};
+  for (const [key, value] of Object.entries(cfg)) {
+    if (PROJECT_SAFE_FIELDS.has(key)) {
+      out[key] = structuredClone(value);
+    }
+  }
+  for (const denied of PROJECT_DENIED_PATHS) deleteProjectDeniedPath(out, denied);
+  return out;
+}
+async function readConfigForRewrite(filePath, vault) {
+  let raw;
+  let fileExists = true;
+  try {
+    raw = await fs.readFile(filePath, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw new FsError({
+        message: `Could not read ${filePath}`,
+        code: ERROR_CODES.FS_READ_FAILED,
+        path: filePath,
+        cause: err
+      });
+    }
+    fileExists = false;
+    raw = "{}";
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return decryptConfigSecretsForRewrite(parsed, vault);
+  } catch (err) {
+    if (fileExists) {
+      throw new ConfigError({
+        message: `Config at ${filePath} is not valid JSON`,
+        code: ERROR_CODES.CONFIG_PARSE_FAILED,
+        context: { path: filePath },
+        cause: err
+      });
+    }
+    return {};
+  }
+}
+async function writeConfigMutation(deps, mutator) {
+  const sourcePath = resolvePersistPath(deps);
+  await ensureProjectDir(sourcePath);
+  let mutated = {};
+  let sourceBefore = {};
+  let actualTarget = sourcePath;
+  let wroteSource = false;
+  await withFileLock(sourcePath, async () => {
+    mutated = await readConfigForRewrite(sourcePath, deps.vault);
+    sourceBefore = structuredClone(mutated);
+    mutator(mutated);
+    actualTarget = resolveActualTarget(deps, mutated, sourcePath);
+    if (actualTarget !== sourcePath) return;
+    const toWrite = isProfileOrGlobalTarget(actualTarget, deps) ? mutated : filterSafeForProject(mutated);
+    await backupCurrent(void 0, actualTarget);
+    await atomicWrite(
+      actualTarget,
+      JSON.stringify(encryptConfigSecrets(toWrite, deps.vault), null, 2),
+      { mode: 384 }
+    );
+    try {
+      await appendHistory(sourceBefore, toWrite, "Settings updated", void 0, actualTarget);
+    } catch {
+    }
+    wroteSource = true;
+  });
+  if (!wroteSource) {
+    await ensureProjectDir(actualTarget);
+    await withFileLock(actualTarget, async () => {
+      const destinationBefore = await readConfigForRewrite(actualTarget, deps.vault);
+      const effectiveConfig = deepMerge(destinationBefore, mutated);
+      const toWrite = isProfileOrGlobalTarget(actualTarget, deps) ? effectiveConfig : filterSafeForProject(effectiveConfig);
+      await backupCurrent(void 0, actualTarget);
+      await atomicWrite(
+        actualTarget,
+        JSON.stringify(encryptConfigSecrets(toWrite, deps.vault), null, 2),
+        { mode: 384 }
+      );
+      try {
+        await appendHistory(
+          destinationBefore,
+          toWrite,
+          "Settings scope changed and settings were updated",
+          void 0,
+          actualTarget
+        );
+      } catch {
+      }
+    });
+  }
+  return mutated;
+}
+async function persistAutonomySetting(deps, mutator) {
+  const decrypted = await writeConfigMutation(deps, (config) => {
+    const autonomy = config.autonomy ?? {};
+    mutator(
+      autonomy
+    );
+    config.autonomy = autonomy;
+  });
+  if (deps.updateStore !== false) {
+    deps.configStore.update({
+      autonomy: decrypted.autonomy
+    });
+  }
+}
+async function persistConfigSetting(deps, mutator) {
+  const decrypted = await writeConfigMutation(deps, mutator);
+  if (deps.updateStore !== false) {
+    deps.configStore.update(decrypted);
+  }
+}
+async function persistTelegramConfig(deps, mutator) {
+  const decrypted = await writeConfigMutation({ ...deps, forceGlobal: true }, (config) => {
+    const extensions = config.extensions ?? {};
+    const telegram = extensions.telegram ?? {};
+    mutator(telegram);
+    extensions.telegram = telegram;
+    config.extensions = extensions;
+  });
+  await deps.vault.flushHardening?.();
+  deps.configStore.update({
+    extensions: decrypted.extensions
+  });
+}
+function deriveFsAccessPair(input) {
+  if (input.allowOutsideProjectRoot !== void 0) {
+    const allow = input.allowOutsideProjectRoot;
+    return { allowOutsideProjectRoot: allow, restrictToProjectRoot: !allow };
+  }
+  if (input.restrictFsToRoot !== void 0) {
+    const restrict = input.restrictFsToRoot;
+    return { allowOutsideProjectRoot: !restrict, restrictToProjectRoot: restrict };
+  }
+  return void 0;
+}
+
+export {
+  filterSafeForProject,
+  persistAutonomySetting,
+  persistConfigSetting,
+  persistTelegramConfig,
+  deriveFsAccessPair
+};
+//# sourceMappingURL=chunk-SFBFYIOW.js.map

package/dist/{chunk-RMQNCHGO.js → chunk-TI7KLHYX.js}

@@ -2,6 +2,115 @@ import {
   theme
 } from "./chunk-QD544J2B.js";
 
+// src/boot/tool-restriction-flags.ts
+function parseToolList(flag, value) {
+  if (value === void 0) return void 0;
+  if (value === true || typeof value === "string" && !value.trim()) {
+    throw new Error(`--${flag} needs a comma-separated list of tool names`);
+  }
+  const names = String(value).split(/[\s,]+/).map((name) => name.trim()).filter(Boolean);
+  const scoped = names.find((name) => name.includes("("));
+  if (scoped) {
+    throw new Error(
+      `--${flag}: scoped rules like "${scoped}" are not supported; list whole tool names (exec policy lives in config tools.exec)`
+    );
+  }
+  return names;
+}
+function resolveLaunchAllowedTools(flags) {
+  return parseToolList("allowed-tools", flags["allowed-tools"]);
+}
+function resolveToolRestriction(flags) {
+  const only = parseToolList("only-tools", flags["only-tools"]);
+  const deny = parseToolList("disallowed-tools", flags["disallowed-tools"]);
+  if (only === void 0 && deny === void 0) return void 0;
+  return { ...only ? { only } : {}, deny: deny ?? [] };
+}
+function unknownRestrictedToolNames(restriction, isRegistered) {
+  return [...restriction.only ?? [], ...restriction.deny].filter(
+    (name) => !name.endsWith("*") && !name.includes("__") && !isRegistered(name)
+  );
+}
+
+// src/boot/restricted-mode.ts
+import { lockToProjectRoot, lockYoloOff, ToolCapabilities } from "@wrongstack/core/security";
+var RESTRICTED_ENV = "WRONGSTACK_RESTRICTED";
+var RESTRICTED_DENY_CAPABILITIES = [
+  ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.SHELL_RESTRICTED,
+  ToolCapabilities.SHELL_EXEC,
+  ToolCapabilities.NET_OUTBOUND,
+  ToolCapabilities.PACKAGE_INSTALL,
+  ToolCapabilities.CONFIG_MUTATE,
+  ToolCapabilities.FS_WRITE_OUTSIDE_PROJECT,
+  ToolCapabilities.TOOL_MUTATE_ANY,
+  ToolCapabilities.MCP_PROXY
+];
+var CONFLICTING_FLAGS = [
+  "yolo",
+  "yolo-destructive",
+  "full-auto",
+  "mcp-config",
+  // Pre-approving a tool would let writes skip the prompt this mode promises.
+  "allowed-tools"
+];
+function isRestrictedMode(flags) {
+  return flags["restricted"] === true || process.env[RESTRICTED_ENV] === "1";
+}
+function validateRestrictedMode(flags) {
+  if (!isRestrictedMode(flags)) return false;
+  const conflict = CONFLICTING_FLAGS.find(
+    (name) => flags[name] !== void 0 && flags[name] !== false
+  );
+  if (conflict) throw new Error(`--${conflict} cannot be combined with --restricted`);
+  return true;
+}
+function withRestrictedTools(restriction, restricted) {
+  if (!restricted) return restriction;
+  return {
+    ...restriction?.only ? { only: restriction.only } : {},
+    deny: [...restriction?.deny ?? [], "mcp__*"],
+    denyCapabilities: RESTRICTED_DENY_CAPABILITIES,
+    requireDeclaredCapabilities: true
+  };
+}
+var RESTRICTED_NOTICE = "Restricted mode: no shell, network, installs or MCP tools; files stay inside the project; YOLO is off.";
+var announced = false;
+function activateRestrictedMode(flags, write) {
+  if (!validateRestrictedMode(flags)) return false;
+  lockToProjectRoot();
+  lockYoloOff();
+  process.env[RESTRICTED_ENV] = "1";
+  if (!announced) {
+    announced = true;
+    write(`${RESTRICTED_NOTICE}
+`);
+  }
+  return true;
+}
+
+// src/boot/safe-mode.ts
+var SAFE_MODE_ENV = "WRONGSTACK_SAFE_MODE";
+function isSafeMode(flags) {
+  return flags["safe-mode"] === true || process.env[SAFE_MODE_ENV] === "1";
+}
+function propagateSafeMode(flags) {
+  const on = isSafeMode(flags);
+  if (on) process.env[SAFE_MODE_ENV] = "1";
+  return on;
+}
+var SAFE_MODE_NOTICE = "Safe mode: third-party plugins, hooks, configured MCP servers, skills and instruction overrides are off.";
+var announced2 = false;
+function announceSafeMode(flags, write) {
+  const on = propagateSafeMode(flags);
+  if (on && !announced2) {
+    announced2 = true;
+    write(`${SAFE_MODE_NOTICE}
+`);
+  }
+  return on;
+}
+
 // src/diff-renderer.ts
 import { color, sanitizeTerminalText } from "@wrongstack/core/utils";
 function diffLineStyle(line) {
@@ -17,7 +126,6 @@ function renderDiff(diff) {
 }
 
 // src/permission-prompt.ts
-import { alwaysAllowUnavailableReason } from "@wrongstack/core/security";
 import {
   color as color2,
   sanitizeTerminalPreview,
@@ -26,6 +134,15 @@ import {
   unifiedDiff,
   writeOut
 } from "@wrongstack/core/utils";
+function makeHeadlessPromptDelegate(write = (text) => process.stderr.write(text)) {
+  return async (tool) => {
+    write(
+      `${theme.warn("\u26A0")} ${tool.name} needs approval but no terminal is attached to ask \u2014 denied. Grant it up front with --allowed-tools ${tool.name} or --yolo.
+`
+    );
+    return "no";
+  };
+}
 function makePromptDelegate(reader) {
   return async (tool, input, suggestedPattern, signal) => {
     if (signal?.aborted) return "no";
@@ -41,18 +158,15 @@ ${theme.warn("\u26A0 APPROVAL REQUIRED")} ${theme.primary("\u2502")} ${theme.bol
     if (preview) writeOut(`${preview}
 `);
     writeOut(color2.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
-    const noAlwaysReason = alwaysAllowUnavailableReason(tool, input);
-    if (noAlwaysReason) {
-      writeOut(`${color2.dim(`(no "always" for this call \u2014 ${noAlwaysReason})`)}
-`);
-    }
     const options = [
       { key: "y", label: "yes", value: "yes" },
       { key: "n", label: "no", value: "no" },
-      ...noAlwaysReason ? [] : [{ key: "a", label: "always", value: "always" }],
+      { key: "a", label: "remember same input/args", value: "always-exact" },
+      ...tool.name === "exec" ? [{ key: "c", label: "remember executable with any args", value: "always-command" }] : [],
+      { key: "t", label: "remember tool with any input", value: "always-tool" },
       { key: "d", label: "deny", value: "deny" }
     ];
-    const alwaysHint = noAlwaysReason ? "" : `  ${theme.bold("[a]")}lways allow (${sanitizeTerminalText2(suggestedPattern)})`;
+    const alwaysHint = `  ${theme.bold("[a]")} same input (${sanitizeTerminalText2(suggestedPattern)})${tool.name === "exec" ? "  [c] command, any args" : ""}  [t] tool, any input`;
     const answer = await reader.readKey(
       `${theme.bold("[y]")}es  ${theme.bold("[n]")}o${alwaysHint}  ${theme.bold("[d]")}eny: `,
       options,
@@ -61,8 +175,11 @@ ${theme.warn("\u26A0 APPROVAL REQUIRED")} ${theme.primary("\u2502")} ${theme.bol
     return answer;
   };
 }
+function makeStdinPromptDelegate(reader, stdinIsTTY = process.stdin.isTTY === true) {
+  return stdinIsTTY ? makePromptDelegate(reader) : makeHeadlessPromptDelegate();
+}
 function makeConfirmAwaiter(reader) {
-  const delegate = makePromptDelegate(reader);
+  const delegate = makeStdinPromptDelegate(reader);
   return async (tool, input, _toolUseId, suggestedPattern) => {
     const result = await delegate(tool, input, suggestedPattern);
     return result;
@@ -474,12 +591,20 @@ on disconnect with exponential backoff, up to 3 attempts"._
 
 export {
   renderDiff,
-  makePromptDelegate,
+  makeStdinPromptDelegate,
   makeConfirmAwaiter,
+  resolveLaunchAllowedTools,
+  resolveToolRestriction,
+  unknownRestrictedToolNames,
+  isRestrictedMode,
+  withRestrictedTools,
+  activateRestrictedMode,
+  isSafeMode,
+  announceSafeMode,
   isSimpleUiFullAuto,
   applySimpleUiFullAutoProfile,
   configureSimpleUiRuntimeContext,
   detectProjectFacts,
   renderAgentsTemplate
 };
-//# sourceMappingURL=chunk-RMQNCHGO.js.map
+//# sourceMappingURL=chunk-TI7KLHYX.js.map

package/dist/{chunk-2ENZU66X.js → chunk-WQV2NP57.js}

@@ -1,10 +1,10 @@
 import {
   helpCmd,
   versionCmd
-} from "./chunk-6WRKAACA.js";
+} from "./chunk-5JYDKG5B.js";
 import {
   parseArgs
-} from "./chunk-C3Z4N6A6.js";
+} from "./chunk-Q4INH2DG.js";
 
 // src/boot/short-circuit-flags.ts
 async function handleHelpVersionShortCircuit(argv) {
@@ -22,11 +22,11 @@ async function handleHelpVersionShortCircuit(argv) {
   }
   if (earlyFlags["help"] === true) {
     if (positional.length > 0) {
-      const { subcommandNames } = await import("./subcommands-XSLXMIDP.js");
+      const { subcommandNames } = await import("./subcommands-Q6ORSB2E.js");
       if (subcommandNames.includes(positional[0])) {
         const first = positional[0];
         const deep = positional[1];
-        const { renderDeepHelp, renderFocusedHelp } = await import("./per-subcommand-help-DHTYU524.js");
+        const { renderDeepHelp, renderFocusedHelp } = await import("./per-subcommand-help-QDAQASPZ.js");
         if (deep && renderDeepHelp(`${first}:${deep}`, stubRenderer)) {
           return 0;
         }
@@ -43,4 +43,4 @@ async function handleHelpVersionShortCircuit(argv) {
 export {
   handleHelpVersionShortCircuit
 };
-//# sourceMappingURL=chunk-2ENZU66X.js.map
+//# sourceMappingURL=chunk-WQV2NP57.js.map

package/dist/{chunk-B4JLSXZB.js → chunk-WSTVGC2C.js}

@@ -6,7 +6,13 @@ import os from "node:os";
 import * as path from "node:path";
 import { isSecretField } from "@wrongstack/core/security";
 import { ERROR_CODES, FsError } from "@wrongstack/core/types";
-import { atomicWrite, resolveWstackPaths, toErrorMessage, writeErr } from "@wrongstack/core/utils";
+import {
+  atomicWrite,
+  resolveWstackPaths,
+  toErrorMessage,
+  withFileLock,
+  writeErr
+} from "@wrongstack/core/utils";
 var defaultUidFn = () => os.userInfo().uid;
 async function getFileUid(filePath) {
   try {
@@ -89,7 +95,11 @@ function maskConfigSecrets(cfg) {
   if (typeof cfg !== "object" || cfg === null) return {};
   const out = {};
   for (const [k, v] of Object.entries(cfg)) {
-    if (isSecretField(k)) {
+    if (k.toLowerCase() === "apikeys" && Array.isArray(v) && v.every(
+      (entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry) && ("label" in entry || "id" in entry) && "apiKey" in entry
+    )) {
+      out[k] = maskValue(v);
+    } else if (isSecretField(k)) {
       out[k] = REDACTED;
     } else {
       out[k] = maskValue(v);
@@ -101,7 +111,14 @@ function reviveSecrets(masked, current) {
   if (masked === REDACTED) return current;
   if (Array.isArray(masked)) {
     const cur = Array.isArray(current) ? current : [];
-    return masked.map((item, i) => reviveSecrets(item, cur[i]));
+    return masked.map((item, i) => {
+      const record = item && typeof item === "object" && !Array.isArray(item) ? item : void 0;
+      const identityKey = typeof record?.["label"] === "string" ? "label" : typeof record?.["id"] === "string" ? "id" : void 0;
+      const matched = identityKey ? cur.find(
+        (candidate) => candidate && typeof candidate === "object" && !Array.isArray(candidate) && candidate[identityKey] === record?.[identityKey]
+      ) : cur[i];
+      return reviveSecrets(item, matched);
+    });
   }
   if (typeof masked !== "object" || masked === null) return masked;
   const curObj = typeof current === "object" && current !== null && !Array.isArray(current) ? current : {};
@@ -271,10 +288,12 @@ async function appendHistory(oldCfg, newCfg, description, homeFn = defaultHomeDi
       cause: err
     });
   }
-  const idx = await readIndex(homeFn, targetConfigPath);
-  idx.entries.unshift({ id, timestamp, description });
-  await pruneHistoryEntries(idx, homeFn, targetConfigPath);
-  await writeIndex(idx, homeFn, targetConfigPath);
+  await withFileLock(historyIndexPath(homeFn, targetConfigPath), async () => {
+    const idx = await readIndex(homeFn, targetConfigPath);
+    idx.entries.unshift({ id, timestamp, description });
+    await pruneHistoryEntries(idx, homeFn, targetConfigPath);
+    await writeIndex(idx, homeFn, targetConfigPath);
+  });
   return id;
 }
 async function listHistory(homeFn = defaultHomeDir, targetConfigPath) {
@@ -302,39 +321,34 @@ async function restoreFromHistory(id, homeFn = defaultHomeDir, targetConfigPath)
       error: "Operation denied: config file is not owned by current user"
     };
   }
-  await backupCurrent(homeFn, targetConfigPath);
-  let oldCfg = {};
-  try {
-    const raw = await fs.readFile(configPath(homeFn, targetConfigPath), "utf8");
-    oldCfg = JSON.parse(raw);
-  } catch {
-  }
-  const restored = reviveSecrets(entry.snapshotMasked, oldCfg);
-  try {
-    await atomicWrite(configPath(homeFn, targetConfigPath), JSON.stringify(restored, null, 2), {
-      mode: 384
-    });
-  } catch (err) {
-    return { ok: false, backupId: null, error: String(err) };
-  }
-  const backupId = await appendHistory(
-    oldCfg,
-    restored,
-    `Restored from history ${id}`,
-    homeFn,
-    targetConfigPath
-  );
-  return { ok: true, backupId };
+  const cfg = configPath(homeFn, targetConfigPath);
+  return withFileLock(cfg, async () => {
+    await backupCurrent(homeFn, targetConfigPath);
+    let oldCfg = {};
+    try {
+      const raw = await fs.readFile(cfg, "utf8");
+      oldCfg = JSON.parse(raw);
+    } catch {
+    }
+    const restored = reviveSecrets(entry.snapshotMasked, oldCfg);
+    try {
+      await atomicWrite(cfg, JSON.stringify(restored, null, 2), { mode: 384 });
+    } catch (err) {
+      return { ok: false, backupId: null, error: String(err) };
+    }
+    const backupId = await appendHistory(
+      oldCfg,
+      restored,
+      `Restored from history ${id}`,
+      homeFn,
+      targetConfigPath
+    );
+    return { ok: true, backupId };
+  });
 }
 async function restoreLast(homeFn = defaultHomeDir, targetConfigPath) {
   const last = backupLastPath(homeFn, targetConfigPath);
   const cfg = configPath(homeFn, targetConfigPath);
-  let oldCfg = {};
-  try {
-    const raw = await fs.readFile(cfg, "utf8");
-    oldCfg = JSON.parse(raw);
-  } catch {
-  }
   let lastCfg = {};
   try {
     const raw = await fs.readFile(last, "utf8");
@@ -345,14 +359,28 @@ async function restoreLast(homeFn = defaultHomeDir, targetConfigPath) {
   if (!await checkConfigOwnership(homeFn, defaultUidFn, targetConfigPath)) {
     return { ok: false, error: "Operation denied: config file is not owned by current user" };
   }
-  await backupCurrent(homeFn, targetConfigPath);
-  try {
-    await atomicWrite(cfg, JSON.stringify(lastCfg, null, 2));
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-  await appendHistory(oldCfg, lastCfg, "Restored from config.json.last", homeFn, targetConfigPath);
-  return { ok: true };
+  return withFileLock(cfg, async () => {
+    let oldCfg = {};
+    try {
+      const raw = await fs.readFile(cfg, "utf8");
+      oldCfg = JSON.parse(raw);
+    } catch {
+    }
+    await backupCurrent(homeFn, targetConfigPath);
+    try {
+      await atomicWrite(cfg, JSON.stringify(lastCfg, null, 2), { mode: 384 });
+    } catch (err) {
+      return { ok: false, error: String(err) };
+    }
+    await appendHistory(
+      oldCfg,
+      lastCfg,
+      "Restored from config.json.last",
+      homeFn,
+      targetConfigPath
+    );
+    return { ok: true };
+  });
 }
 
 export {
@@ -363,4 +391,4 @@ export {
   restoreFromHistory,
   restoreLast
 };
-//# sourceMappingURL=chunk-B4JLSXZB.js.map
+//# sourceMappingURL=chunk-WSTVGC2C.js.map