@wrongstack/cli 1.0.24 → 1.0.27

package/dist/chunk-LKPEBZBE.js

@@ -0,0 +1,143 @@
+
+// src/boot/stream-json.ts
+function parseOutputFormat(value) {
+  if (value === void 0) return void 0;
+  if (value === "text" || value === "json" || value === "stream-json") return value;
+  throw new Error(
+    `--output-format must be text, json or stream-json (got ${value === true ? "nothing" : `"${value}"`})`
+  );
+}
+var LEADER = "leader";
+function isLeader(agentId) {
+  return agentId === void 0 || agentId === LEADER;
+}
+function simplifyBlocks(content) {
+  const out = [];
+  for (const block of content ?? []) {
+    if (block.type === "text") out.push({ type: "text", text: block.text });
+    else if (block.type === "tool_use") {
+      out.push({ type: "tool_use", id: block.id, name: block.name, input: block.input });
+    }
+  }
+  return out;
+}
+function startStreamJson(opts) {
+  const emit = (payload) => {
+    opts.write(`${JSON.stringify(payload)}
+`);
+  };
+  const offs = [];
+  if (opts.includePartialMessages) {
+    offs.push(
+      opts.events.on("provider.text_delta", (e) => {
+        if (isLeader(e.ctx?.agentId)) emit({ type: "text_delta", text: e.text });
+      })
+    );
+  }
+  offs.push(
+    opts.events.on("provider.response", (e) => {
+      if (!isLeader(e.ctx?.agentId)) return;
+      emit({
+        type: "assistant",
+        model: e.model,
+        content: simplifyBlocks(e.content),
+        stopReason: e.stopReason,
+        usage: e.usage
+      });
+    })
+  );
+  offs.push(
+    opts.events.on("tool.executed", (e) => {
+      if (!isLeader(e.agentId)) return;
+      emit({
+        type: "tool_result",
+        id: e.id ?? null,
+        name: e.name,
+        ok: e.ok,
+        durationMs: e.durationMs,
+        output: e.output ?? null,
+        outputBytes: e.outputBytes ?? null
+      });
+    })
+  );
+  return () => {
+    for (const off of offs) off();
+  };
+}
+function streamJsonInit(info) {
+  return `${JSON.stringify({ type: "init", ...info })}
+`;
+}
+
+// src/boot/structured-output.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { validateAgainstSchema } from "@wrongstack/core/utils";
+async function resolveJsonSchemaFlag(value, cwd) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("--json-schema needs a JSON Schema file path or an inline JSON object");
+  }
+  const trimmed = value.trim();
+  let text = trimmed;
+  let source = "inline JSON";
+  if (!trimmed.startsWith("{")) {
+    const file = path.resolve(cwd, trimmed);
+    source = file;
+    try {
+      text = await fs.readFile(file, "utf8");
+    } catch (err) {
+      const reason = err.code ?? String(err);
+      throw new Error(`--json-schema: cannot read ${file} (${reason})`);
+    }
+  }
+  let schema;
+  try {
+    schema = JSON.parse(text);
+  } catch (err) {
+    throw new Error(`--json-schema: ${source} is not valid JSON (${err.message})`);
+  }
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+    throw new Error(`--json-schema: ${source} must be a JSON Schema object`);
+  }
+  return schema;
+}
+function withSchemaInstruction(query, schema) {
+  return `${query}
+
+When you are done, reply with ONLY a JSON value that validates against this JSON Schema \u2014 no prose, no code fence:
+${JSON.stringify(schema)}`;
+}
+function checkStructuredAnswer(text, schema) {
+  if (!text?.trim()) return { ok: false, errors: ["the answer was empty"] };
+  const fenced = text.trim().match(/^```(?:json)?\s*\n([\s\S]*?)\n?```$/);
+  const body = (fenced?.[1] ?? text).trim();
+  let value;
+  try {
+    value = JSON.parse(body);
+  } catch (err) {
+    return { ok: false, errors: [`not valid JSON (${err.message})`] };
+  }
+  const result = validateAgainstSchema(value, schema);
+  if (result.ok) return { ok: true, value };
+  return {
+    ok: false,
+    errors: result.errors.map((e) => `${e.path || "(root)"}: ${e.message}`)
+  };
+}
+function repairPrompt(errors) {
+  return `Your last answer did not validate against the JSON Schema:
+${errors.map((e) => `- ${e}`).join("\n")}
+Reply with ONLY the corrected JSON value.`;
+}
+
+export {
+  parseOutputFormat,
+  startStreamJson,
+  streamJsonInit,
+  resolveJsonSchemaFlag,
+  withSchemaInstruction,
+  checkStructuredAnswer,
+  repairPrompt
+};
+//# sourceMappingURL=chunk-LKPEBZBE.js.map

package/dist/chunk-N57IU5FG.js

@@ -0,0 +1,58 @@
+
+// src/subcommands/index.ts
+var loaders = {
+  acp: async () => (await import("./acp-M4565YUW.js")).acpCmd,
+  init: async () => (await import("./init-DRMMFG2G.js")).initCmd,
+  auth: async () => (await import("./auth-TE55JF4Z.js")).authCmd,
+  update: async () => (await import("./update-TDZX4IL2.js")).updateCmd,
+  remote: async () => (await import("./remote-GB5VXCCT.js")).remoteCmd,
+  sessions: async () => (await import("./sessions-config-XHLXJ5C3.js")).sessionsCmd,
+  config: async () => (await import("./sessions-config-XHLXJ5C3.js")).configCmd,
+  "config-export": async () => (await import("./config-transfer-RUWLDCNK.js")).configExportCmd,
+  "config-import": async () => (await import("./config-transfer-RUWLDCNK.js")).configImportCmd,
+  rewind: async () => (await import("./rewind-JA3ZLCNM.js")).rewindCmd,
+  replay: async () => (await import("./replay-JJ2NOWD6.js")).replayCmd,
+  audit: async () => (await import("./audit-46YK5DSC.js")).auditCmd,
+  tools: async () => (await import("./tools-skills-GH24UCBY.js")).toolsCmd,
+  skills: async () => (await import("./tools-skills-GH24UCBY.js")).skillsCmd,
+  "skill-suggest": async () => (await import("./skill-suggest-L2EVWB6R.js")).skillSuggestCmd,
+  typesafe: async () => (await import("./typesafe-U7YB2RRV.js")).typesafeCmd,
+  providers: async () => (await import("./providers-models-5Z2PJTEW.js")).providersCmd,
+  models: async () => (await import("./providers-models-5Z2PJTEW.js")).modelsCmd,
+  mcp: async () => (await import("./mcp-LBS45HWZ.js")).mcpCmd,
+  plugin: async () => (await import("./plugin-usage-CIGOOTX3.js")).pluginCmd,
+  plugins: async () => (await import("./plugin-usage-CIGOOTX3.js")).pluginCmd,
+  diag: async () => (await import("./diag-doctor-BIZAFIAT.js")).diagCmd,
+  doctor: async () => (await import("./diag-doctor-BIZAFIAT.js")).doctorCmd,
+  "proxy-status": async () => (await import("./diag-doctor-BIZAFIAT.js")).proxyCmd,
+  export: async () => (await import("./export-VVRIOWFV.js")).exportCmd,
+  usage: async () => (await import("./plugin-usage-CIGOOTX3.js")).usageCmd,
+  version: async () => (await import("./version-help-XJJQ7YSH.js")).versionCmd,
+  help: async () => (await import("./version-help-XJJQ7YSH.js")).helpCmd,
+  projects: async () => (await import("./projects-T4CZCA25.js")).projectsCmd,
+  modeldiag: async () => (await import("./modeldiag-W7XAE625.js")).modeldiagCmd,
+  quick: async () => (await import("./quick-CNB4Z3HS.js")).quickCmd,
+  bench: async () => (await import("./bench-GTLPM22B.js")).benchCmd,
+  chronicle: async () => (await import("./chronicle-UTFETHP6.js")).chronicleCmd,
+  hq: async () => (await import("./hq-44F4OQH2.js")).hqCmd,
+  mailbox: async () => (await import("./mailbox-serve-GNGXEQ2R.js")).mailboxServeCmd,
+  permissions: async () => (await import("./permissions-PL27UHYD.js")).permissionsCmd,
+  project: async () => (await import("./project-AOQI5XTK.js")).projectCmd,
+  governance: async () => (await import("./governance-RYSHV675.js")).governanceCmd,
+  "import-claude-code": async () => (await import("./import-claude-code-AYG24RG2.js")).importClaudeCodeCmd
+};
+var subcommands = Object.fromEntries(
+  Object.entries(loaders).map(
+    ([name, load]) => [
+      name,
+      async (args, deps) => (await load())(args, deps)
+    ]
+  )
+);
+var subcommandNames = Object.keys(loaders);
+
+export {
+  subcommands,
+  subcommandNames
+};
+//# sourceMappingURL=chunk-N57IU5FG.js.map

package/dist/{chunk-2EBVTYJR.js → chunk-NRXWOMK7.js}

@@ -172,14 +172,28 @@ async function dispatch(controller, commandId, type, payload) {
         };
       }
       if (target === "fleet") {
-        const killed = await controller.killFleet?.(sessionId) ?? 0;
+        if (controller.killFleet === void 0) {
+          return {
+            commandId,
+            status: "rejected",
+            message: "this client does not manage a fleet"
+          };
+        }
+        const killed = await controller.killFleet(sessionId);
         return {
           commandId,
           status: "completed",
           message: `fleet stopped (${killed} agents)`
         };
       }
-      const terminated = await controller.terminateAgent?.(target, sessionId) ?? false;
+      if (controller.terminateAgent === void 0) {
+        return {
+          commandId,
+          status: "rejected",
+          message: "this client does not manage subagents"
+        };
+      }
+      const terminated = await controller.terminateAgent(target, sessionId);
       return {
         commandId,
         status: terminated ? "completed" : "rejected",
@@ -320,4 +334,4 @@ export {
   createProjectKanbanAssignHandler,
   createHqCommandDispatcher
 };
-//# sourceMappingURL=chunk-2EBVTYJR.js.map
+//# sourceMappingURL=chunk-NRXWOMK7.js.map

package/dist/chunk-PZQBGUVZ.js

@@ -0,0 +1,18 @@
+
+// src/boot/ascii-mode.ts
+import { installAsciiOutput, isAsciiMode } from "@wrongstack/core/utils";
+var installed = false;
+function applyAsciiMode(flags, env = process.env, streams = [process.stdout, process.stderr]) {
+  if (flags["ascii"] === true) env["WRONGSTACK_TUI_ICON_STYLE"] = "ascii";
+  if (!isAsciiMode(env)) return false;
+  if (!installed) {
+    installed = true;
+    for (const stream of streams) installAsciiOutput(stream);
+  }
+  return true;
+}
+
+export {
+  applyAsciiMode
+};
+//# sourceMappingURL=chunk-PZQBGUVZ.js.map

package/dist/{chunk-MHEBWVXL.js → chunk-Q4INH2DG.js}

@@ -20,6 +20,34 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   // Both are boolean so they cannot swallow the next positional token.
   "no-recovery",
   "recover",
+  // `--continue` / `-c`: resume the most recent session (same pick as a bare
+  // `--resume`). Boolean so `wstack -c "next step"` keeps the prompt.
+  "continue",
+  // `--fork-session` (with --resume/--continue/--recover): branch instead of reopening.
+  "fork-session",
+  // `--strict-mcp-config`: start only the `--mcp-config` servers.
+  "strict-mcp-config",
+  // `--include-partial-messages`: add text_delta events to stream-json output.
+  "include-partial-messages",
+  // `--safe-mode`: start with plugins/hooks/MCP/skills/instruction overrides off.
+  "safe-mode",
+  // `--restricted`: no code-running/network tools, project-root lock, no YOLO.
+  "restricted",
+  // `--record` is read as `=== true`; as a value flag it swallowed the task
+  // (`wstack --record "fix it"` recorded nothing and ran nothing).
+  "record",
+  // Same class: switches read only as `=== true` that would otherwise take the
+  // next token (`--vector-sync "task"`, `typesafe lint-conventions --staged x`).
+  "vector-sync",
+  "allow-all",
+  "no-llm",
+  "staged",
+  "sweep",
+  "n",
+  // `wstack import-claude-code` switches.
+  "apply",
+  "overwrite",
+  "enable-project-servers",
   "output-json",
   "metrics",
   "webui",
@@ -28,6 +56,8 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "full-auto",
   "desktop",
   "open",
+  // `wstack remote --keep`: leave the remote host running after disconnecting.
+  "keep",
   "webui-require-token",
   "require-token",
   "no-check",
@@ -39,6 +69,7 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "skip",
   "skip-index",
   "mouse",
+  "ascii",
   "no-interactive",
   "token-saving-mode",
   "system-lite",
@@ -139,7 +170,13 @@ function parseArgs(argv) {
       }
     } else if (a.startsWith("-") && a.length === 2) {
       const short = a.slice(1);
-      const expand = { v: "verbose", y: "yes", h: "help" };
+      const expand = {
+        v: "verbose",
+        y: "yes",
+        h: "help",
+        c: "continue",
+        r: "resume"
+      };
       const name = expand[short] ?? short;
       if (!BOOLEAN_FLAGS.has(name) && i + 1 < argv.length && !(argv[i + 1] ?? "").startsWith("-")) {
         flags[name] = argv[++i] ?? "";
@@ -151,6 +188,13 @@ function parseArgs(argv) {
     }
   }
   normalizeSurfaceAliases(flags, positional);
+  for (const [camel, kebab] of [
+    ["disallowedTools", "disallowed-tools"],
+    ["allowedTools", "allowed-tools"]
+  ]) {
+    if (flags[camel] !== void 0 && flags[kebab] === void 0) flags[kebab] = flags[camel];
+    delete flags[camel];
+  }
   return { flags, positional };
 }
 function normalizeSurfaceAliases(flags, positional) {
@@ -262,4 +306,4 @@ export {
   parseAuthFlags,
   parseSpawnFlags
 };
-//# sourceMappingURL=chunk-MHEBWVXL.js.map
+//# sourceMappingURL=chunk-Q4INH2DG.js.map

package/dist/{chunk-5SEYGOCH.js → chunk-RDGGWMTI.js}

@@ -1,6 +1,6 @@
 import {
   resolveProviderCfgWithProxy
-} from "./chunk-S4FFHDJG.js";
+} from "./chunk-SDJCLEK6.js";
 import {
   fallbackCodexProviderModels,
   filterCurrentCodexModelIds,
@@ -336,4 +336,4 @@ export {
   setupProvider,
   createGracefulShutdown
 };
-//# sourceMappingURL=chunk-5SEYGOCH.js.map
+//# sourceMappingURL=chunk-RDGGWMTI.js.map

package/dist/{chunk-BLD5DSVA.js → chunk-RGFWGUAB.js}

@@ -1,6 +1,6 @@
 import {
   CLI_VERSION
-} from "./chunk-YBUCXXYZ.js";
+} from "./chunk-F5DCFAKI.js";
 
 // src/hq-publisher.ts
 import { createHqPublisherFromEnv, resolveHqConfig } from "@wrongstack/core/hq";
@@ -445,18 +445,15 @@ function hqExplicitlyDisabled(options) {
   return options.appConfig?.hq?.enabled === false;
 }
 function resolvedHqConnectionKey(options) {
-  if (options.config !== void 0) {
-    if (options.config.enabled === false) return void 0;
-    return options.config.discover === true ? HQ_DISCOVERY_CONNECTION_KEY : `${options.config.url}
-${options.config.token ?? ""}`;
-  }
-  const config = resolveHqConfig({ config: options.appConfig?.hq });
+  const config = options.config !== void 0 ? options.config.enabled === false ? void 0 : options.config : resolveHqConfig({ config: options.appConfig?.hq });
   if (config === void 0) return void 0;
-  return config.discover === true ? HQ_DISCOVERY_CONNECTION_KEY : `${config.url}
+  const endpoint = config.discover === true ? HQ_DISCOVERY_CONNECTION_KEY : `${config.url}
 ${config.token ?? ""}`;
+  return `${endpoint}
+raw=${String(config.rawContent)}`;
 }
 function startCliHqConnection(options) {
-  const shouldOwnKanbanSync = options.onKanbanSnapshot === void 0;
+  const shouldOwnKanbanSync = options.ownKanbanSync !== false && options.onKanbanSnapshot === void 0;
   let kanbanSync;
   const publisherOptions = shouldOwnKanbanSync ? {
     ...options,
@@ -465,17 +462,32 @@ function startCliHqConnection(options) {
   let publisher;
   let publisherKey;
   let timer;
+  const liveOptions = () => options.getAppConfig === void 0 ? publisherOptions : { ...publisherOptions, appConfig: options.getAppConfig() };
+  const retire = () => {
+    if (publisher === void 0) return;
+    kanbanSync?.stop();
+    kanbanSync = void 0;
+    publisher.close();
+    publisher = void 0;
+    publisherKey = void 0;
+    options.onDisconnect?.();
+  };
   const tryConnect = () => {
-    const nextKey = resolvedHqConnectionKey(options);
-    if (nextKey === void 0) return;
+    const current = liveOptions();
+    const nextKey = resolvedHqConnectionKey(current);
+    if (nextKey === void 0) {
+      retire();
+      return;
+    }
     if (publisher !== void 0 && publisherKey === nextKey) {
-      if (nextKey === HQ_DISCOVERY_CONNECTION_KEY) publisher.refreshEndpoint();
+      if (nextKey.startsWith(`${HQ_DISCOVERY_CONNECTION_KEY}
+`)) publisher.refreshEndpoint();
       return;
     }
     publisher?.close();
     publisher = void 0;
     publisherKey = void 0;
-    const next = createCliHqPublisher(publisherOptions);
+    const next = createCliHqPublisher(current);
     if (next === void 0) return;
     publisher = next;
     publisherKey = nextKey;
@@ -495,7 +507,7 @@ function startCliHqConnection(options) {
     options.onConnect?.(next);
   };
   tryConnect();
-  if (!hqExplicitlyDisabled(options)) {
+  if (options.getAppConfig !== void 0 || !hqExplicitlyDisabled(options)) {
     timer = setInterval(tryConnect, options.retryIntervalMs ?? 2500);
     timer.unref?.();
   }
@@ -518,4 +530,4 @@ function startCliHqConnection(options) {
 export {
   startCliHqConnection
 };
-//# sourceMappingURL=chunk-BLD5DSVA.js.map
+//# sourceMappingURL=chunk-RGFWGUAB.js.map

package/dist/{chunk-ZZRSG7VK.js → chunk-RZ4ZDRYA.js}

@@ -1,6 +1,6 @@
 import {
   CLI_VERSION
-} from "./chunk-YBUCXXYZ.js";
+} from "./chunk-F5DCFAKI.js";
 
 // src/update-check.ts
 import * as fs from "node:fs/promises";
@@ -144,7 +144,7 @@ async function checkForUpdate(signalOrOptions, legacyHomeFn) {
     };
   }
   try {
-    const latest = packageName === "standalone-binary" ? await (await import("./standalone-update-MW47J3AK.js")).fetchLatestStandaloneVersion(3e3, signal) : await fetchLatestFromNpm(packageName, 3e3, signal);
+    const latest = packageName === "standalone-binary" ? await (await import("./standalone-update-LZO3MNLH.js")).fetchLatestStandaloneVersion(3e3, signal) : await fetchLatestFromNpm(packageName, 3e3, signal);
     await writeCache({ timestamp: Date.now(), latestVersion: latest, packageName }, hf);
     return {
       current,
@@ -183,4 +183,4 @@ export {
   checkForUpdate,
   getUpdateNotification
 };
-//# sourceMappingURL=chunk-ZZRSG7VK.js.map
+//# sourceMappingURL=chunk-RZ4ZDRYA.js.map

package/dist/{chunk-S4FFHDJG.js → chunk-SDJCLEK6.js}

@@ -12,8 +12,12 @@ function resolveRawProviderConnection(config, providerId) {
   const savedCfg = config.providers?.[providerId];
   const isAccountAlias = savedCfg?.type !== void 0 && savedCfg.type !== providerId;
   const inheritsPrimary = !isAccountAlias && (config.provider === void 0 || config.provider === providerId);
+  const repointed = Array.isArray(savedCfg?.envVars) && savedCfg.envVars.length === 0;
   return {
-    apiKey: savedCfg?.apiKey ?? (inheritsPrimary ? config.apiKey : void 0),
+    // A repointed entry (`envVars: []` sentinel) must not inherit the legacy
+    // top-level key: `leader_model_set` could otherwise make it primary and
+    // carry that key to the new base URL (WS-2026-09-26-01).
+    apiKey: savedCfg?.apiKey ?? (inheritsPrimary && !repointed ? config.apiKey : void 0),
     baseUrl: savedCfg?.baseUrl ?? (inheritsPrimary ? config.baseUrl : void 0)
   };
 }
@@ -90,4 +94,4 @@ export {
   resolveProviderCfgWithProxy,
   buildProviderForId
 };
-//# sourceMappingURL=chunk-S4FFHDJG.js.map
+//# sourceMappingURL=chunk-SDJCLEK6.js.map

package/dist/{chunk-U46QR4WR.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) {
@@ -25,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";
@@ -57,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;
@@ -470,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-U46QR4WR.js.map
+//# sourceMappingURL=chunk-TI7KLHYX.js.map