@wrongstack/cli 1.0.24 → 1.0.27

package/dist/import-claude-code-AYG24RG2.js

@@ -0,0 +1,268 @@
+import {
+  normalizeMcpServerEntry
+} from "./chunk-HLSHFXTO.js";
+import {
+  activeProfileConfigPath
+} from "./chunk-YMXXOOFN.js";
+import {
+  restoreFlags
+} from "./chunk-CSAPOCBP.js";
+
+// src/subcommands/handlers/import-claude-code.ts
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { readJsonObjectFile, setJsonPath, updateJsonObjectFile } from "@wrongstack/core/utils";
+import { mcpEnvPlaceholders } from "@wrongstack/mcp";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var REPOSITORY_STRIPPED_MCP_FIELDS = [
+  "permission",
+  "bearerTokenEnv",
+  "passthroughEnv",
+  "allowPrivateNetworks"
+];
+function envReads(config) {
+  const reads = new Set(mcpEnvPlaceholders(config));
+  if (config.bearerTokenEnv) reads.add(config.bearerTokenEnv);
+  for (const name of config.passthroughEnv ?? []) reads.add(name);
+  return [...reads];
+}
+function describeTarget(config) {
+  if (typeof config.command === "string") {
+    return `runs: ${[config.command, ...config.args ?? []].join(" ")}`;
+  }
+  if (typeof config.url === "string") return `connects to: ${config.url}`;
+  return void 0;
+}
+function samePath(a, b) {
+  const norm = (p) => {
+    const resolved = path.resolve(p).replace(/[\\/]+$/, "");
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+  };
+  return norm(a) === norm(b);
+}
+function projectEntry(userState, projectRoot) {
+  const projects = userState?.["projects"];
+  if (!isRecord(projects)) return void 0;
+  for (const [key, value] of Object.entries(projects)) {
+    if (isRecord(value) && samePath(key, projectRoot)) return value;
+  }
+  return void 0;
+}
+function planClaudeCodeImport(opts) {
+  const { sources } = opts;
+  const mcp = [];
+  const seen = /* @__PURE__ */ new Set();
+  const collect = (servers, source) => {
+    if (!isRecord(servers)) return;
+    for (const [name, raw] of Object.entries(servers)) {
+      if (seen.has(name)) continue;
+      seen.add(name);
+      let config;
+      try {
+        config = normalizeMcpServerEntry(name, raw);
+      } catch (err) {
+        mcp.push({
+          name,
+          source,
+          config: {},
+          action: "skip-invalid",
+          enabled: false,
+          note: err.message
+        });
+        continue;
+      }
+      const exists2 = Object.hasOwn(opts.existingServers, name);
+      const repository = source === "repository";
+      const enabled = !repository || opts.enableProjectServers;
+      const stripped = [];
+      if (repository) {
+        for (const field of REPOSITORY_STRIPPED_MCP_FIELDS) {
+          if (config[field] === void 0) continue;
+          delete config[field];
+          stripped.push(field);
+        }
+        config.origin = "repository";
+      }
+      const reads = envReads(config);
+      const target = describeTarget(config);
+      const notes2 = [
+        target,
+        repository && !enabled ? "from the repository \u2014 imported disabled; review, then `/mcp enable`" : void 0,
+        reads.length > 0 ? `reads environment: ${reads.join(", ")}` : void 0,
+        stripped.length > 0 ? `not imported from the repository: ${stripped.join(", ")} (set them yourself after review)` : void 0
+      ].filter((note) => note !== void 0);
+      mcp.push({
+        name,
+        source,
+        config,
+        action: exists2 ? opts.overwrite ? "overwrite" : "skip-exists" : "add",
+        enabled,
+        ...notes2.length > 0 ? { note: notes2.join("; ") } : {}
+      });
+    }
+  };
+  collect(
+    projectEntry(sources.userState, opts.projectRoot)?.["mcpServers"],
+    "claude-project-local"
+  );
+  collect(sources.userState?.["mcpServers"], "claude-user");
+  collect(sources.projectMcp?.["mcpServers"] ?? sources.projectMcp, "repository");
+  const notes = [];
+  if (sources.skillDirs.length > 0) {
+    notes.push(
+      `Skills: ${sources.skillDirs.join(", ")} \u2014 already loaded in place (skills.readClaudeSkills); nothing to copy.`
+    );
+  }
+  let hookCount = 0;
+  let ruleCount = 0;
+  for (const { content } of sources.settings) {
+    const hooks = content["hooks"];
+    if (isRecord(hooks)) {
+      for (const list of Object.values(hooks)) if (Array.isArray(list)) hookCount += list.length;
+    }
+    const permissions = content["permissions"];
+    if (isRecord(permissions)) {
+      for (const key of ["allow", "deny", "ask"]) {
+        const list = permissions[key];
+        if (Array.isArray(list)) ruleCount += list.length;
+      }
+    }
+  }
+  if (hookCount > 0) {
+    notes.push(
+      `Hooks: ${hookCount} found \u2014 not imported (matcher semantics differ). Recreate under config.hooks; see docs/hooks.md.`
+    );
+  }
+  if (ruleCount > 0) {
+    notes.push(
+      `Permission rules: ${ruleCount} found \u2014 not imported (a mistranslated deny is worse than none). Use /permissions or --allowed-tools/--disallowed-tools.`
+    );
+  }
+  for (const file of sources.instructionFiles) {
+    notes.push(
+      `Instructions: ${file} \u2014 not imported. Project context lives in .wrongstack/AGENTS.md; merge what applies there.`
+    );
+  }
+  return { mcp, notes };
+}
+async function readJson(file) {
+  let raw;
+  try {
+    raw = await fs.readFile(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : void 0;
+  } catch {
+    throw new Error(`${file} is not valid JSON`);
+  }
+}
+async function exists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readClaudeCodeSources(projectRoot, userHome = os.homedir()) {
+  const settingsFiles = [
+    path.join(userHome, ".claude", "settings.json"),
+    path.join(projectRoot, ".claude", "settings.json"),
+    path.join(projectRoot, ".claude", "settings.local.json")
+  ];
+  const settings = [];
+  for (const file of settingsFiles) {
+    const content = await readJson(file);
+    if (content) settings.push({ file, content });
+  }
+  const instructionCandidates = [
+    path.join(userHome, ".claude", "CLAUDE.md"),
+    path.join(projectRoot, "CLAUDE.md"),
+    path.join(projectRoot, ".claude", "CLAUDE.md")
+  ];
+  const skillCandidates = [
+    path.join(userHome, ".claude", "skills"),
+    path.join(projectRoot, ".claude", "skills")
+  ];
+  return {
+    userState: await readJson(path.join(userHome, ".claude.json")),
+    projectMcp: await readJson(path.join(projectRoot, ".mcp.json")),
+    settings,
+    instructionFiles: (await Promise.all(instructionCandidates.map(async (f) => await exists(f) ? f : null))).filter((f) => f !== null),
+    skillDirs: (await Promise.all(skillCandidates.map(async (d) => await exists(d) ? d : null))).filter((d) => d !== null)
+  };
+}
+var SOURCE_LABEL = {
+  "claude-user": "~/.claude.json (user)",
+  "claude-project-local": "~/.claude.json (this project)",
+  repository: ".mcp.json (repository)"
+};
+var importClaudeCodeCmd = async (args, deps) => {
+  args = restoreFlags(args, deps, ["apply", "overwrite", "enable-project-servers"]);
+  const apply = args.includes("--apply");
+  const overwrite = args.includes("--overwrite");
+  const enableProjectServers = args.includes("--enable-project-servers");
+  let sources;
+  try {
+    sources = await readClaudeCodeSources(deps.projectRoot, deps.userHome);
+  } catch (err) {
+    deps.renderer.writeError(`import-claude-code: ${err.message}`);
+    return 1;
+  }
+  const configPath = activeProfileConfigPath(deps.paths, deps.config);
+  const current = await readJsonObjectFile(configPath);
+  const existingServers = isRecord(current["mcpServers"]) ? current["mcpServers"] : {};
+  const plan = planClaudeCodeImport({
+    sources,
+    projectRoot: deps.projectRoot,
+    existingServers,
+    overwrite,
+    enableProjectServers
+  });
+  const out = (line) => deps.renderer.write(`${line}
+`);
+  out(apply ? "Importing from Claude Code:" : "Claude Code import preview (nothing written):");
+  if (plan.mcp.length === 0) out("  MCP servers: none found");
+  for (const c of plan.mcp) {
+    const state = c.action.startsWith("skip") ? "" : c.enabled ? " [enabled]" : " [disabled]";
+    const verb = {
+      add: "add",
+      overwrite: "overwrite",
+      "skip-exists": "skip (exists; --overwrite to replace)",
+      "skip-invalid": "skip (invalid)"
+    }[c.action];
+    out(`  MCP ${c.name} \u2014 ${verb}${state} \u2014 ${SOURCE_LABEL[c.source]}`);
+    if (c.note) out(`      ${c.note}`);
+  }
+  for (const note of plan.notes) out(`  ${note}`);
+  const writes = plan.mcp.filter((c) => c.action === "add" || c.action === "overwrite");
+  if (!apply) {
+    if (writes.length > 0)
+      out(`
+Run with --apply to write ${writes.length} server(s) to ${configPath}.`);
+    return 0;
+  }
+  if (writes.length > 0) {
+    await updateJsonObjectFile(configPath, (config) => {
+      for (const c of writes) {
+        setJsonPath(config, ["mcpServers", c.name], { ...c.config, enabled: c.enabled });
+      }
+    });
+  }
+  out(`
+Wrote ${writes.length} server(s) to ${configPath}.`);
+  return 0;
+};
+export {
+  REPOSITORY_STRIPPED_MCP_FIELDS,
+  importClaudeCodeCmd,
+  planClaudeCodeImport,
+  readClaudeCodeSources
+};
+//# sourceMappingURL=import-claude-code-AYG24RG2.js.map

package/dist/index.js

@@ -2,28 +2,32 @@
 import {
   applyNodeEnvDefault,
   applySessionShellDefault
-} from "./chunk-QBBF7GIK.js";
-import {
-  parseArgs
-} from "./chunk-MHEBWVXL.js";
+} from "./chunk-LBPLTTZ6.js";
 import {
   CLI_VERSION
-} from "./chunk-YBUCXXYZ.js";
+} from "./chunk-F5DCFAKI.js";
+import {
+  parseArgs
+} from "./chunk-Q4INH2DG.js";
 
 // src/cli-entry-main.ts
 async function main(argv) {
   applyNodeEnvDefault();
   applySessionShellDefault();
   const earlyFlags = parseArgs(argv).flags;
+  if (earlyFlags["ascii"] === true || process.env["WRONGSTACK_TUI_ICON_STYLE"]) {
+    const { applyAsciiMode } = await import("./ascii-mode-SG4PRNLP.js");
+    applyAsciiMode(earlyFlags);
+  }
   if (earlyFlags["help"] === true || earlyFlags["version"] === true) {
-    const { handleHelpVersionShortCircuit } = await import("./short-circuit-flags-SDT53OML.js");
+    const { handleHelpVersionShortCircuit } = await import("./short-circuit-flags-5TNTJPQR.js");
     const earlyExit = await handleHelpVersionShortCircuit(argv);
     if (earlyExit !== null) return earlyExit;
   }
-  const { initializeCli } = await import("./cli-context-34Q5IJRA.js");
+  const { initializeCli } = await import("./cli-context-C7RBSWHF.js");
   const cliCtx = await initializeCli(argv);
   if (typeof cliCtx === "number") return cliCtx;
-  const { runInteractive } = await import("./cli-main-AELJDBGU.js");
+  const { runInteractive } = await import("./cli-main-TQTH73ZK.js");
   return runInteractive(cliCtx);
 }
 

package/dist/live-settings-input.d.ts

@@ -19,6 +19,7 @@ export interface LiveSettingsInput {
     featureMemory?: boolean | undefined;
     featureSkills?: boolean | undefined;
     featureModelsRegistry?: boolean | undefined;
+    featureToolCoach?: boolean | undefined;
     featureTokenSaving?: TokenSavingTier | undefined;
     allowOutsideProjectRoot?: boolean | undefined;
     contextAutoCompact?: boolean | undefined;

package/dist/{mailbox-serve-WDOCH6KR.js → mailbox-serve-GNGXEQ2R.js}

@@ -1,7 +1,7 @@
 import {
   startCliHqConnection
-} from "./chunk-BLD5DSVA.js";
-import "./chunk-YBUCXXYZ.js";
+} from "./chunk-RGFWGUAB.js";
+import "./chunk-F5DCFAKI.js";
 
 // src/subcommands/handlers/mailbox-serve.ts
 import { createServer } from "node:http";
@@ -361,4 +361,4 @@ function printHelp(deps) {
 export {
   mailboxServeCmd
 };
-//# sourceMappingURL=mailbox-serve-WDOCH6KR.js.map
+//# sourceMappingURL=mailbox-serve-GNGXEQ2R.js.map

package/dist/{modeldiag-36OGAL5C.js → modeldiag-W7XAE625.js}

@@ -1,6 +1,9 @@
 import {
   applyProviderOAuthRefresh
-} from "./chunk-3OCUS3VN.js";
+} from "./chunk-LDCGZJTC.js";
+import {
+  discoverAndMergeProviders
+} from "./chunk-D5GB5MHA.js";
 import {
   checkMark,
   costLabel,
@@ -15,18 +18,15 @@ import {
   scoreBar,
   speedLabel
 } from "./chunk-BBHWW6LR.js";
-import {
-  discoverAndMergeProviders
-} from "./chunk-D5GB5MHA.js";
-import {
-  activeProfileConfigPath
-} from "./chunk-YMXXOOFN.js";
 import {
   resolveRawProviderConnection
-} from "./chunk-S4FFHDJG.js";
+} from "./chunk-SDJCLEK6.js";
 import {
   mutateConfigProviders
 } from "./chunk-LUMETJFO.js";
+import {
+  activeProfileConfigPath
+} from "./chunk-YMXXOOFN.js";
 
 // src/subcommands/handlers/modeldiag.ts
 import * as fs from "node:fs/promises";
@@ -825,4 +825,4 @@ var modeldiagCmd = async (args, deps) => {
 export {
   modeldiagCmd
 };
-//# sourceMappingURL=modeldiag-36OGAL5C.js.map
+//# sourceMappingURL=modeldiag-W7XAE625.js.map

package/dist/{per-subcommand-help-XE77MTGJ.js → per-subcommand-help-QDAQASPZ.js}

@@ -7,7 +7,7 @@ import {
   renderFocusedHelpToString,
   renderGenericHelp,
   subcommandsWithFocusedHelp
-} from "./chunk-SKPDE62W.js";
+} from "./chunk-EPR42SWM.js";
 import "./chunk-YTEOAWOJ.js";
 export {
   deepSubcommandsWithFocusedHelp,
@@ -19,4 +19,4 @@ export {
   renderGenericHelp,
   subcommandsWithFocusedHelp
 };
-//# sourceMappingURL=per-subcommand-help-XE77MTGJ.js.map
+//# sourceMappingURL=per-subcommand-help-QDAQASPZ.js.map

package/dist/permission-prompt.d.ts

@@ -2,6 +2,14 @@ import type { InputReader, Tool } from '@wrongstack/core/types';
 type PromptDecision = 'yes' | 'no' | 'always' | 'always-exact' | 'always-command' | 'always-tool' | 'deny';
 /** Signature the Agent expects for confirming tool calls. */
 export type ConfirmAwaiter = (tool: Tool, input: unknown, toolUseId: string, suggestedPattern: string) => Promise<'yes' | 'no' | 'always' | 'always-exact' | 'always-command' | 'always-tool' | 'deny'>;
+/**
+ * Approval "prompt" for a process with no terminal on stdin — a script, CI,
+ * `wstack "task" < /dev/null`, piped input. Nobody can answer, and the
+ * terminal prompt used to wait for a key that never came, so the run hung
+ * until it was killed. Refuse instead, and say on stderr (stdout may be a
+ * JSON payload) how to grant it up front.
+ */
+export declare function makeHeadlessPromptDelegate(write?: (text: string) => void): (tool: Tool) => Promise<PromptDecision>;
 /**
  * The terminal approval prompt.
  *
@@ -16,6 +24,12 @@ export declare function makePromptDelegate(reader: InputReader): (tool: Tool, in
  * Create a ConfirmAwaiter for the CLI path. Wraps makePromptDelegate
  * with the ConfirmAwaiter type signature expected by the Agent.
  */
+/**
+ * The terminal prompt when stdin is a terminal, the headless refusal
+ * otherwise. Both approval paths (policy prompt and executor confirm) go
+ * through this, so neither can wait on a keypress nobody can make.
+ */
+export declare function makeStdinPromptDelegate(reader: InputReader, stdinIsTTY?: boolean): ReturnType<typeof makePromptDelegate>;
 export declare function makeConfirmAwaiter(reader: InputReader): ConfirmAwaiter;
 export {};
 //# sourceMappingURL=permission-prompt.d.ts.map

package/dist/permission-rules-view.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Text views of the permission rule list and of one explained call, shared by
+ * `wstack permissions` and the in-session `/permissions` command.
+ */
+import type { Context } from '@wrongstack/core/agent';
+import type { PermissionPolicy, PermissionRule, PermissionTrace, Tool } from '@wrongstack/core/types';
+export interface ExplainedCall {
+    trace: PermissionTrace;
+    rules: PermissionRule[];
+    /** The rule that decided the call. */
+    rule: PermissionRule | undefined;
+}
+/** Trace one call through the policy and the executor's gate, and name its rule. */
+export declare function explainCall(policy: Pick<PermissionPolicy, 'explain' | 'listRules'>, tool: Tool, input: unknown, ctx: Context, yolo: boolean): Promise<ExplainedCall>;
+export declare function describePermissionRule(rule: PermissionRule): string;
+export declare function formatPermissionRules(rules: readonly PermissionRule[]): string;
+export declare function formatExplainedCall({ trace, rule }: ExplainedCall): string;
+//# sourceMappingURL=permission-rules-view.d.ts.map

package/dist/{permissions-CFDLXETM.js → permissions-PL27UHYD.js}

@@ -1,23 +1,45 @@
+import {
+  explainCall,
+  formatExplainedCall,
+  formatPermissionRules
+} from "./chunk-4TVYGG6G.js";
 
 // src/subcommands/handlers/permissions.ts
-import { DefaultPermissionPolicy } from "@wrongstack/core/security";
+import { compilePermissionRules } from "@wrongstack/core/security";
 import { resolveWstackPaths } from "@wrongstack/core/utils";
+import { createProjectPermissionPolicy } from "@wrongstack/runtime";
 var permissionsCmd = async (args, deps) => {
   const subCmd = args[0];
   if (subCmd === "help" || subCmd === "--help" || subCmd === "-h" || !subCmd || subCmd === "explain" && !args[1]) {
-    if (subCmd !== "explain" && subCmd !== "help" && subCmd !== void 0) {
-      deps.renderer.writeError(`Unknown permissions subcommand: ${subCmd}
-`);
-    }
     deps.renderer.write(usage());
-    return subCmd && subCmd !== "explain" && subCmd !== "help" && subCmd !== void 0 ? 1 : 0;
+    return 0;
   }
-  if (subCmd !== "explain") {
+  if (subCmd !== "explain" && subCmd !== "rules") {
     deps.renderer.writeError(`Unknown permissions subcommand: ${subCmd}
 `);
     deps.renderer.write(usage());
     return 1;
   }
+  const jsonOutput = deps.flags?.["json"] === true || args.includes("--json");
+  const built = buildPolicy(deps);
+  if (typeof built === "string") {
+    deps.renderer.writeError(`${built}
+`);
+    return 1;
+  }
+  const { policy, ctx, yolo, yoloSource } = built;
+  if (subCmd === "rules") {
+    const rules = await compilePermissionRules(policy, ctx, { yolo });
+    if (jsonOutput) deps.renderer.write(`${JSON.stringify(rules, null, 2)}
+`);
+    else
+      deps.renderer.writeLine(
+        `YOLO: ${yolo ? "on" : "off"} (${yoloSource})
+
+${formatPermissionRules(rules)}`
+      );
+    return 0;
+  }
   const toolName = args[1];
   if (!toolName) {
     deps.renderer.writeError("Missing tool name.\n");
@@ -27,7 +49,6 @@ var permissionsCmd = async (args, deps) => {
   const inputIdx = args.indexOf("--input");
   const flagInput = deps.flags?.["input"];
   const rawInput = typeof flagInput === "string" ? flagInput : inputIdx >= 0 && inputIdx + 1 < args.length ? args[inputIdx + 1] : void 0;
-  const jsonOutput = deps.flags?.["json"] === true || args.includes("--json");
   let input = {};
   if (rawInput) {
     try {
@@ -50,67 +71,68 @@ var permissionsCmd = async (args, deps) => {
     );
     return 1;
   }
+  const explained = await explainCall(policy, tool, input, ctx, yolo);
+  if (jsonOutput) {
+    deps.renderer.write(
+      `${JSON.stringify({ ...explained.trace, rule: explained.rule }, null, 2)}
+`
+    );
+  } else {
+    deps.renderer.writeLine(
+      `YOLO: ${yolo ? "on" : "off"} (${yoloSource})
+
+${formatExplainedCall(explained)}`
+    );
+  }
+  return 0;
+};
+function buildPolicy(deps) {
   const paths = resolveWstackPaths({ projectRoot: deps.projectRoot, userHome: deps.userHome });
-  const trustFile = paths.projectTrust;
   const readSubjects = /* @__PURE__ */ new Set();
   const ctx = {
     projectRoot: deps.projectRoot,
     cwd: deps.cwd,
+    workingDir: deps.cwd,
+    meta: {},
+    provider: { id: deps.config.provider },
     hasRead(subject) {
       return readSubjects.has(subject);
     }
   };
-  const policy = new DefaultPermissionPolicy({
-    trustFile,
-    yolo: deps.flags?.["yolo"] ?? false
-  });
-  await policy.reload();
-  const trace = await policy.explain(tool, input, ctx);
-  if (jsonOutput) {
-    deps.renderer.write(JSON.stringify(trace, null, 2) + "\n");
-  } else {
-    deps.renderer.write(formatTrace(trace) + "\n");
+  const yoloFlag = deps.flags?.["yolo"];
+  const yolo = typeof yoloFlag === "boolean" ? yoloFlag : deps.config.yolo === true;
+  try {
+    const policy = createProjectPermissionPolicy({
+      projectRoot: deps.projectRoot,
+      trustFile: paths.projectTrust,
+      config: deps.config,
+      permission: { yolo }
+    })();
+    return { policy, ctx, yolo, yoloSource: typeof yoloFlag === "boolean" ? "--yolo" : "config" };
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
   }
-  return 0;
-};
-function formatTrace(trace) {
-  const lines = [];
-  lines.push(`Permission trace for "${trace.toolName}"`);
-  lines.push(`Subject: ${trace.subject ?? "(none)"}`);
-  lines.push("");
-  for (let i = 0; i < trace.steps.length; i++) {
-    const step = trace.steps[i];
-    const winner = i === trace.winnerIndex ? " \u2190 WINNER" : "";
-    const matched = step.matched ? "\u2713" : " ";
-    lines.push(`  ${matched} [${i}] ${step.rule}${winner}`);
-    lines.push(`        decision: ${step.decision}  source: ${step.source}`);
-    lines.push(`        ${step.detail}`);
-    if (i < trace.steps.length - 1) lines.push("");
-  }
-  lines.push("");
-  lines.push(`Effective: ${trace.decision.permission} (source: ${trace.decision.source})`);
-  if (trace.decision.reason) {
-    lines.push(`Reason: ${trace.decision.reason}`);
-  }
-  if (trace.decision.riskTier) {
-    lines.push(`Risk tier: ${trace.decision.riskTier}`);
-  }
-  return lines.join("\n");
 }
 function usage() {
   return `Usage:
+  wstack permissions rules [--json]
   wstack permissions explain <tool> --input '<json>' [--json]
 
 Examples:
+  wstack permissions rules
   wstack permissions explain bash --input '{"command":"rm -rf /"}'
   wstack permissions explain read --input '{"path":".env"}' --json
 
 Flags:
   --input <json>   Tool input arguments as a JSON object
   --json           Output as structured JSON instead of human-readable text
+  --yolo           Show the rules as they apply with YOLO on
+
+Inside a session, /permissions shows the same with that session\u2019s YOLO,
+answers and /permissions allow|deny rules.
 `;
 }
 export {
   permissionsCmd
 };
-//# sourceMappingURL=permissions-CFDLXETM.js.map
+//# sourceMappingURL=permissions-PL27UHYD.js.map

package/dist/{plugin-usage-S5LVGMBW.js → plugin-usage-CIGOOTX3.js}

@@ -4,10 +4,10 @@ import {
 import {
   activeProfileConfigPath
 } from "./chunk-YMXXOOFN.js";
-import "./chunk-WSTVGC2C.js";
 import {
   restoreFlags
 } from "./chunk-CSAPOCBP.js";
+import "./chunk-WSTVGC2C.js";
 
 // src/subcommands/handlers/plugin-usage.ts
 var pluginCmd = async (args, deps) => {
@@ -41,4 +41,4 @@ export {
   pluginCmd,
   usageCmd
 };
-//# sourceMappingURL=plugin-usage-S5LVGMBW.js.map
+//# sourceMappingURL=plugin-usage-CIGOOTX3.js.map

package/dist/{plugins-RHBIVLI7.js → plugins-HQTXUD6A.js}

@@ -1,17 +1,19 @@
 import {
   BUILTIN_PLUGIN_FACTORIES,
+  BUILTIN_PLUGIN_NAME_HINTS,
   DEPRECATED_PLUGIN_NAMES,
   _resetDeprecatedWarningsForTests,
   builtinPluginNameFromSpec,
   pluginNameFromSpec,
   setupPlugins,
   warnIfDeprecatedPluginName
-} from "./chunk-JF2MULWF.js";
+} from "./chunk-YHYINL47.js";
 import "./chunk-EWKESL4L.js";
 import "./chunk-L2RVEQWO.js";
 import "./chunk-WSTVGC2C.js";
 export {
   BUILTIN_PLUGIN_FACTORIES,
+  BUILTIN_PLUGIN_NAME_HINTS,
   DEPRECATED_PLUGIN_NAMES,
   _resetDeprecatedWarningsForTests,
   builtinPluginNameFromSpec,
@@ -19,4 +21,4 @@ export {
   setupPlugins,
   warnIfDeprecatedPluginName
 };
-//# sourceMappingURL=plugins-RHBIVLI7.js.map
+//# sourceMappingURL=plugins-HQTXUD6A.js.map

package/dist/preflight.d.ts

@@ -39,7 +39,7 @@ export declare function applySessionShellDefault(): void;
  * callers get back the (possibly refreshed) `UpdateInfo`
  * so version-aware UI can render without re-fetching.
  */
-export declare function applyPrintUpdateNotice(initialUpdateInfo: UpdateInfo | undefined): Promise<UpdateInfo | undefined>;
+export declare function applyPrintUpdateNotice(initialUpdateInfo: UpdateInfo | undefined, config?: Config | undefined): Promise<UpdateInfo | undefined>;
 /**
  * Seed the stream-debug singleton from persisted config so
  * `WireAdapter` picks it up on construction. Runtime toggles