@cydm/pie 1.0.46 → 1.0.47

package/dist/cli.js

@@ -19,7 +19,7 @@ import {
   getThemesDir,
   migrateConfigFromAgentDir,
   truncateHeadTail
-} from "./chunks/chunk-75JWZPRK.js";
+} from "./chunks/chunk-U4B6RJ6Z.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -66,10 +66,11 @@ import {
   resolveExtensionIdentity,
   restoreExecutionState,
   selectToolsForRuntimePolicy,
+  setEnablementInMap,
   setExtensionEnabledInSettings,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-PKR3PO73.js";
+} from "./chunks/chunk-IJMP3JTX.js";
 import "./chunks/chunk-FKAO25XH.js";
 import {
   Deref,
@@ -1236,12 +1237,12 @@ var require_supports_color = __commonJS({
     "use strict";
     var os9 = __require("os");
     var tty = __require("tty");
-    var hasFlag2 = require_has_flag();
+    var hasFlag = require_has_flag();
     var { env } = process;
     var forceColor;
-    if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false") || hasFlag2("color=never")) {
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
       forceColor = 0;
-    } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
       forceColor = 1;
     }
     if ("FORCE_COLOR" in env) {
@@ -1268,10 +1269,10 @@ var require_supports_color = __commonJS({
       if (forceColor === 0) {
         return 0;
       }
-      if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) {
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
         return 3;
       }
-      if (hasFlag2("color=256")) {
+      if (hasFlag("color=256")) {
         return 2;
       }
       if (haveStream && !streamIsTTY && forceColor === void 0) {
@@ -46223,6 +46224,13 @@ var ModelRegistry = class {
 // src/core/settings-manager.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
+function getDisabledToolNames(settingsManager) {
+  return new Set(typeof settingsManager?.getDisabledTools === "function" ? settingsManager.getDisabledTools() : []);
+}
+function filterEnabledTools(tools, settingsManager) {
+  const disabled = getDisabledToolNames(settingsManager);
+  return disabled.size > 0 ? tools.filter((tool) => !disabled.has(tool.name)) : [...tools];
+}
 var SettingsManager = class {
   settingsPath;
   legacyConfigPath;
@@ -46379,6 +46387,44 @@ var SettingsManager = class {
     this.writeSettingsValue(nextSettings);
     this.settings = nextSettings;
   }
+  /** Raw skill enablement map. */
+  getSkillSettings() {
+    return this.settings.skills ?? {};
+  }
+  /** Whether a skill is enabled; absent entries mean "enabled". */
+  isSkillEnabled(name) {
+    return isExtensionEnabled(name, this.getSkillSettings());
+  }
+  /** Set or clear (enabled=undefined) a skill enablement override. */
+  setSkillEnabled(name, enabled) {
+    const nextSettings = { ...this.settings };
+    setEnablementInMap(nextSettings, "skills", name, enabled);
+    this.writeSettingsValue(nextSettings);
+    this.settings = nextSettings;
+  }
+  /** Disabled runtime tool names (may contain names no longer installed). */
+  getDisabledTools() {
+    return [...this.settings.tools?.disabledTools ?? []];
+  }
+  /** Whether a runtime tool is enabled; absent means "enabled". */
+  isToolEnabled(name) {
+    return !this.getDisabledTools().includes(name);
+  }
+  /** Enable/disable a runtime tool by name (persisted in settings.json). */
+  setToolEnabled(name, enabled) {
+    const disabled = this.getDisabledTools().filter((tool) => tool !== name);
+    if (!enabled) disabled.push(name);
+    disabled.sort();
+    const nextTools = { ...this.settings.tools ?? {} };
+    delete nextTools.disabledTools;
+    if (disabled.length > 0) nextTools.disabledTools = disabled;
+    const nextSettings = { ...this.settings, tools: nextTools };
+    if (Object.keys(nextTools).length === 0) {
+      delete nextSettings.tools;
+    }
+    this.writeSettingsValue(nextSettings);
+    this.settings = nextSettings;
+  }
 };
 
 // src/doctor.ts
@@ -46772,28 +46818,54 @@ function formatDoctorReport(report) {
 }
 
 // src/permissions-help.ts
+var MODE_RULES = {
+  default: [
+    "File tools read and write inside the current workspace.",
+    "~/.pie is allowlisted for Pie configuration and session support.",
+    "Shell commands run from the workspace and return structured output, timeout, and truncation details.",
+    "web_research is read-only, uses provider-native web/search/fetch capabilities, and does not grant bash/curl web scraping permission.",
+    "Protected paths from extensions can block reads/writes even when tools are present."
+  ],
+  plan: [
+    "The agent should inspect and plan before making changes.",
+    "Risky write/shell actions should be deferred until the user approves the plan."
+  ],
+  yolo: [
+    "/settings/yolo relaxes filesystem sandbox directory restrictions.",
+    "It does not make destructive shell commands safe; use it only in trusted workspaces."
+  ],
+  subagents: [
+    "Subagents inherit the parent tool set, then runtime policy removes write and high-risk tools.",
+    "Subagents are expected to return evidence and hand off required writes to the parent agent."
+  ]
+};
+var MODE_TITLES = {
+  default: "Default mode",
+  plan: "Plan mode",
+  yolo: "YOLO mode",
+  subagents: "Subagents"
+};
+function buildPermissionsData() {
+  return {
+    modes: Object.fromEntries(Object.entries(MODE_RULES).map(([key, rules]) => [key, [...rules]])),
+    tools: Object.entries(BUILTIN_TOOL_CAPABILITY_METADATA).map(([name, meta]) => ({
+      name,
+      ...meta.riskClass ? { riskClass: meta.riskClass } : {},
+      ...meta.permissionScope ? { permissionScope: meta.permissionScope } : {},
+      ...meta.availableInPlanMode ? { availableInPlanMode: true } : {},
+      ...meta.allowedForSubagentByDefault ? { allowedForSubagentByDefault: true } : {},
+      ...meta.highRisk ? { highRisk: true } : {}
+    }))
+  };
+}
 function formatPermissionsHelp() {
-  const toolLines = Object.entries(BUILTIN_TOOL_CAPABILITY_METADATA).map(([name, meta]) => `  - ${name}: ${meta.riskClass ?? "unknown"}${meta.permissionScope ? `, scope=${meta.permissionScope}` : ""}${meta.availableInPlanMode ? ", plan" : ""}${meta.allowedForSubagentByDefault ? ", subagent" : ""}${meta.highRisk ? ", high-risk" : ""}`).join("\n");
+  const data = buildPermissionsData();
+  const modeSections = Object.entries(data.modes).map(([key, rules]) => `${MODE_TITLES[key]}:
+${rules.map((rule) => `  - ${rule}`).join("\n")}`).join("\n\n");
+  const toolLines = data.tools.map((tool) => `  - ${tool.name}: ${tool.riskClass ?? "unknown"}${tool.permissionScope ? `, scope=${tool.permissionScope}` : ""}${tool.availableInPlanMode ? ", plan" : ""}${tool.allowedForSubagentByDefault ? ", subagent" : ""}${tool.highRisk ? ", high-risk" : ""}`).join("\n");
   return `Pie permissions and safety model
 
-Default mode:
-  - File tools read and write inside the current workspace.
-  - ~/.pie is allowlisted for Pie configuration and session support.
-  - Shell commands run from the workspace and return structured output, timeout, and truncation details.
-  - web_research is read-only, uses provider-native web/search/fetch capabilities, and does not grant bash/curl web scraping permission.
-  - Protected paths from extensions can block reads/writes even when tools are present.
-
-Plan mode:
-  - The agent should inspect and plan before making changes.
-  - Risky write/shell actions should be deferred until the user approves the plan.
-
-YOLO mode:
-  - /settings/yolo relaxes filesystem sandbox directory restrictions.
-  - It does not make destructive shell commands safe; use it only in trusted workspaces.
-
-Subagents:
-  - Subagents inherit the parent tool set, then runtime policy removes write and high-risk tools.
-  - Subagents are expected to return evidence and hand off required writes to the parent agent.
+${modeSections}
 
 Tool policy snapshot:
 ${toolLines}
@@ -47042,30 +47114,677 @@ async function probeModelsConfig(options) {
     message: passed ? `web_search probe passed using ${attempts.find((attempt) => attempt.status === "passed")?.route}.` : "web_search probe failed for all configured candidate routes."
   };
 }
-function parseModelsCommandArgs(args) {
-  const parsed = { force: false, stdout: false, json: false };
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === "--force") {
-      parsed.force = true;
-    } else if (arg === "--json") {
-      parsed.json = true;
-    } else if (arg === "--stdout") {
-      parsed.stdout = true;
-    } else if (arg === "--probe" && args[i + 1]) {
-      parsed.probe = args[i + 1] === "web_search" ? "web_search" : void 0;
-      i += 1;
-    } else if (arg.startsWith("--probe=")) {
-      const value = arg.slice("--probe=".length);
-      parsed.probe = value === "web_search" ? "web_search" : void 0;
-    } else if (arg === "--path" && args[i + 1]) {
-      parsed.path = args[i + 1];
-      i += 1;
-    } else if (arg.startsWith("--path=")) {
-      parsed.path = arg.slice("--path=".length);
+
+// src/command-args.ts
+var HELP_FLAG_NAMES = /* @__PURE__ */ new Set(["--help", "-h"]);
+function parseCommandArgs(args, spec) {
+  const flags = /* @__PURE__ */ new Map();
+  const positionals = /* @__PURE__ */ new Map();
+  const flagByName = /* @__PURE__ */ new Map();
+  for (const flag of spec.flags) {
+    flagByName.set(flag.name, flag);
+    for (const alias of flag.aliases ?? []) {
+      flagByName.set(alias, flag);
+    }
+  }
+  let help = false;
+  let positionalIndex = 0;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (HELP_FLAG_NAMES.has(arg)) {
+      help = true;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const equals = arg.indexOf("=");
+      const head = equals >= 0 ? arg.slice(0, equals) : arg;
+      const inlineValue = equals >= 0 ? arg.slice(equals + 1) : void 0;
+      if (HELP_FLAG_NAMES.has(head)) {
+        return {
+          help,
+          flags,
+          positionals,
+          error: {
+            code: "unknown_flag",
+            flag: arg,
+            message: `Unknown flag: ${arg}. Use --help (no value) instead.`
+          }
+        };
+      }
+      const flagSpec = flagByName.get(head);
+      if (!flagSpec) {
+        return {
+          help,
+          flags,
+          positionals,
+          error: {
+            code: "unknown_flag",
+            flag: arg,
+            message: `Unknown flag: ${arg}. Run 'pie ${spec.path} --help' for supported flags.`
+          }
+        };
+      }
+      if (flagSpec.kind === "boolean") {
+        if (inlineValue !== void 0) {
+          return {
+            help,
+            flags,
+            positionals,
+            error: {
+              code: "unknown_flag",
+              flag: arg,
+              message: `Flag ${flagSpec.name} does not take a value.`
+            }
+          };
+        }
+        flags.set(flagSpec.name, true);
+        continue;
+      }
+      let value = inlineValue;
+      if (value === void 0) {
+        const next = args[index + 1];
+        if (next === void 0 || next.startsWith("--")) {
+          return {
+            help,
+            flags,
+            positionals,
+            error: {
+              code: "missing_value",
+              flag: flagSpec.name,
+              message: `Flag ${flagSpec.name} requires a value.`
+            }
+          };
+        }
+        value = next;
+        index += 1;
+      }
+      if (flagSpec.repeatable) {
+        const existing = flags.get(flagSpec.name);
+        const collected = Array.isArray(existing) ? existing : [];
+        collected.push(value);
+        flags.set(flagSpec.name, collected);
+      } else {
+        flags.set(flagSpec.name, value);
+      }
+      continue;
+    }
+    const slot = spec.positional[positionalIndex];
+    if (!slot) {
+      return {
+        help,
+        flags,
+        positionals,
+        error: {
+          code: "unexpected_positional",
+          positional: arg,
+          message: `Unexpected argument: ${arg}. Run 'pie ${spec.usage}' to see expected arguments.`
+        }
+      };
+    }
+    if (slot.variadic) {
+      const collected = getPositionals({ help, flags, positionals }, slot.name);
+      collected.push(arg);
+      positionals.set(slot.name, collected);
+      continue;
+    }
+    positionals.set(slot.name, arg);
+    positionalIndex += 1;
+  }
+  if (help) return { help, flags, positionals };
+  for (const slot of spec.positional) {
+    if (!slot.required) continue;
+    const value = positionals.get(slot.name);
+    if (value === void 0 || Array.isArray(value) && value.length === 0) {
+      return {
+        help,
+        flags,
+        positionals,
+        error: {
+          code: "missing_positional",
+          positional: slot.name,
+          message: `Missing required argument: <${slot.name}>.`
+        }
+      };
+    }
+  }
+  return { help, flags, positionals };
+}
+function getFlagString(parsed, name) {
+  const value = parsed.flags.get(name);
+  if (typeof value === "string") return value;
+  return void 0;
+}
+function getFlagStrings(parsed, name) {
+  const value = parsed.flags.get(name);
+  return Array.isArray(value) ? value : [];
+}
+function getFlagBool(parsed, name) {
+  return parsed.flags.get(name) === true;
+}
+function getPositional(parsed, name) {
+  const value = parsed.positionals.get(name);
+  if (typeof value === "string") return value;
+  return void 0;
+}
+function getPositionals(parsed, name) {
+  const value = parsed.positionals.get(name);
+  return Array.isArray(value) ? value : [];
+}
+function renderCommandUsage(spec) {
+  return `Usage: pie ${spec.usage}`;
+}
+function renderCommandHelp(spec) {
+  const lines = [renderCommandUsage(spec), "", spec.summary];
+  if (spec.positional.length > 0) {
+    lines.push("", "Arguments:");
+    for (const slot of spec.positional) {
+      const marker = slot.required ? `<${slot.name}>` : `[${slot.name}]`;
+      lines.push(
+        `  ${marker}${slot.variadic ? "..." : ""}  ${slot.description}`
+      );
+    }
+  }
+  if (spec.flags.length > 0) {
+    lines.push("", "Options:");
+    for (const flag of spec.flags) {
+      const names = [flag.name, ...flag.aliases ?? []].join(", ");
+      const valueHint = flag.kind === "string" ? " <value>" : "";
+      lines.push(`  ${names}${valueHint}  ${flag.description}`);
+    }
+  }
+  lines.push("", "  --help, -h  Show this help");
+  return lines.join("\n");
+}
+
+// src/command-specs.ts
+var SESSIONS_LIST_SPEC = {
+  path: "sessions list",
+  summary: "List sessions, most recently updated first.",
+  usage: "sessions list [--json] [--limit <n>] [--cursor <cursor>] [--cwd <path> | --all] [--fields <list>] [--full]",
+  flags: [
+    { name: "--json", kind: "boolean", description: "Emit the machine envelope (compact JSON)." },
+    { name: "--limit", kind: "string", description: "Page size, 1-1000 (default 50)." },
+    { name: "--cursor", kind: "string", description: "Resume from meta.nextCursor of a previous page." },
+    { name: "--cwd", kind: "string", description: "Only sessions whose cwd matches this path." },
+    { name: "--all", kind: "boolean", description: "Ignore cwd scoping (JSON mode defaults to the current directory)." },
+    { name: "--fields", kind: "string", description: "Extra row fields (comma list): createdAt, cwd, activeEntryId, rootEntryId, sourceSessionId, sourceEntryId, sourceActiveEntryId, forkBaseEntryId, or all." },
+    { name: "--full", kind: "boolean", description: "Disable name truncation." }
+  ],
+  positional: []
+};
+var SESSIONS_READ_SPEC = {
+  path: "sessions read",
+  summary: "Read a session's active transcript path.",
+  usage: "sessions read <sessionId> [--json] [--limit <n>] [--before <cursor>] [--fields <list>] [--full]",
+  flags: [
+    { name: "--json", kind: "boolean", description: "Emit the machine envelope (compact JSON)." },
+    { name: "--limit", kind: "string", description: "Max events per page, 1-1000 (default 200)." },
+    { name: "--before", kind: "string", description: "Event entryId or sequence number to read up to (exclusive)." },
+    { name: "--fields", kind: "string", description: "Extra event fields (comma list): timestamp, turnId, message, or all." },
+    { name: "--full", kind: "boolean", description: "Disable content truncation." }
+  ],
+  positional: [
+    { name: "sessionId", required: true, description: "Session identifier." }
+  ]
+};
+var SESSIONS_RENAME_SPEC = {
+  path: "sessions rename",
+  summary: "Rename a session.",
+  usage: "sessions rename <sessionId> <name...> [--json] [--cwd <path>]",
+  flags: [
+    { name: "--json", kind: "boolean", description: "Emit the machine envelope (compact JSON)." },
+    { name: "--cwd", kind: "string", description: "Also update the session's cwd." }
+  ],
+  positional: [
+    { name: "sessionId", required: true, description: "Session identifier." },
+    { name: "name", required: true, variadic: true, description: "New session name." }
+  ]
+};
+var SESSIONS_REWIND_SPEC = {
+  path: "sessions rewind",
+  summary: "Move a session's active head back to an earlier entry.",
+  usage: "sessions rewind <sessionId> --to <entryId> [--json]",
+  flags: [
+    { name: "--json", kind: "boolean", description: "Emit the machine envelope (compact JSON)." },
+    { name: "--to", kind: "string", description: "Target entryId on the active path." }
+  ],
+  positional: [
+    { name: "sessionId", required: true, description: "Session identifier." }
+  ]
+};
+var SESSIONS_FORK_SPEC = {
+  path: "sessions fork",
+  summary: "Fork a session at an entry into a new session.",
+  usage: "sessions fork <sessionId> --from <entryId> --target <newSessionId> --name <name> [--cwd <path>] [--force] [--json]",
+  flags: [
+    { name: "--json", kind: "boolean", description: "Emit the machine envelope (compact JSON)." },
+    { name: "--from", kind: "string", description: "EntryId to fork at." },
+    { name: "--target", kind: "string", description: "Identifier for the new session." },
+    { name: "--name", kind: "string", description: "Name for the new session." },
+    { name: "--cwd", kind: "string", description: "cwd recorded on the new session." },
+    { name: "--force", kind: "boolean", description: "Overwrite the target session if it already exists." }
+  ],
+  positional: [
+    { name: "sessionId", required: true, description: "Source session identifier." }
+  ]
+};
+var DOCTOR_SPEC = {
+  path: "doctor",
+  summary: "Diagnose local Pie configuration and runtime dependencies.",
+  usage: "doctor [--json]",
+  flags: [
+    { name: "--json", kind: "boolean", description: "Emit the machine envelope (compact JSON)." }
+  ],
+  positional: []
+};
+var MODELS_INIT_SPEC = {
+  path: "models init",
+  summary: "Create a starter models.json template.",
+  usage: "models init [--path <path>] [--force] [--stdout] [--json]",
+  flags: [
+    { name: "--json", kind: "boolean", description: "Emit the machine envelope (compact JSON)." },
+    { name: "--path", kind: "string", description: "Target models.json path (default ~/.pie/models.json)." },
+    { name: "--force", kind: "boolean", description: "Overwrite an existing file." },
+    { name: "--stdout", kind: "boolean", description: "Print the template instead of writing a file." }
+  ],
+  positional: []
+};
+var MODELS_VALIDATE_SPEC = {
+  path: "models validate",
+  summary: "Validate models.json configuration.",
+  usage: "models validate [--path <path>] [--probe web_search] [--json]",
+  flags: [
+    { name: "--json", kind: "boolean", description: "Emit the machine envelope (compact JSON)." },
+    { name: "--path", kind: "string", description: "models.json path to validate (default ~/.pie/models.json)." },
+    { name: "--probe", kind: "string", description: "Run a live capability probe (web_search)." }
+  ],
+  positional: []
+};
+var EXTENSIONS_LIST_SPEC = {
+  path: "extensions list",
+  summary: "List discovered extensions.",
+  usage: "extensions list [--json] [--extension-path <dir>] [--fields <list>]",
+  flags: [
+    { name: "--json", kind: "boolean", description: "Emit the machine envelope (compact JSON)." },
+    { name: "--extension-path", kind: "string", repeatable: true, description: "Extra extension search directory (repeatable)." },
+    { name: "--no-builtin-extensions", kind: "boolean", description: "Skip built-in extensions." },
+    { name: "--no-extensions", kind: "boolean", description: "Skip all discovered extensions." },
+    { name: "--fields", kind: "string", description: "Extra row fields (comma list): entryPath, description, or all." }
+  ],
+  positional: []
+};
+var EXTENSIONS_TOGGLE_SPEC = {
+  path: "extensions enable/disable",
+  summary: "Toggle extension enablement in user or project settings.",
+  usage: "extensions <enable|disable> <name> [--project | --user] [--json]",
+  flags: [
+    { name: "--json", kind: "boolean", description: "Emit the machine envelope (compact JSON)." },
+    { name: "--project", kind: "boolean", description: "Write ./.pie/settings.json (default is user scope)." },
+    { name: "--user", kind: "boolean", description: "Write ~/.pie/settings.json (default)." }
+  ],
+  positional: [
+    { name: "name", required: true, description: "Extension identity." }
+  ]
+};
+var PERMISSIONS_SPEC = {
+  path: "permissions",
+  summary: "Explain Pie tool and shell safety defaults.",
+  usage: "permissions [--json]",
+  flags: [
+    { name: "--json", kind: "boolean", description: "Emit the machine envelope (compact JSON)." }
+  ],
+  positional: []
+};
+var CAPABILITIES_SPEC = {
+  path: "capabilities",
+  summary: "Report command surface, flags, and output schema generation for agents.",
+  usage: "capabilities [--json]",
+  flags: [
+    { name: "--json", kind: "boolean", description: "Emit the machine envelope (compact JSON)." }
+  ],
+  positional: []
+};
+var CHAT_SPEC = {
+  path: "chat",
+  summary: "Interactive chat (default), print mode, or JSONL protocol mode.",
+  usage: "chat [prompt] [--raw-output | --json-output | --json-events] [--session-id <id>] ...",
+  flags: [
+    { name: "--raw-output", kind: "boolean", description: "Print assistant text only in non-interactive mode." },
+    { name: "--json-output", kind: "boolean", description: "Print structured JSON in non-interactive mode." },
+    { name: "--json-events", kind: "boolean", description: "Run JSONL protocol mode over stdin/stdout." },
+    { name: "--event-detail", kind: "string", description: "JSON-events payload detail: compact (default) caps tool results and summaries; full keeps historical caps." },
+    { name: "--session-id", kind: "string", description: "Reuse or create a specific session." },
+    { name: "--resume-required", kind: "boolean", description: "Fail if --session-id cannot be resumed." },
+    { name: "--developer-instructions", kind: "string", description: "Append stable host/developer instructions." },
+    { name: "--developer-instructions-file", kind: "string", description: "Read developer instructions from a file." },
+    { name: "--extension-path", kind: "string", repeatable: true, description: "Extra extension search directory (repeatable)." },
+    { name: "--no-builtin-extensions", kind: "boolean", description: "Skip built-in extensions." },
+    { name: "--no-extensions", kind: "boolean", description: "Skip all discovered extensions." }
+  ],
+  positional: [
+    { name: "prompt", required: false, description: "Initial prompt (starts print mode instead of the TUI)." }
+  ]
+};
+var MANAGEMENT_COMMAND_SPECS = [
+  CHAT_SPEC,
+  DOCTOR_SPEC,
+  MODELS_INIT_SPEC,
+  MODELS_VALIDATE_SPEC,
+  SESSIONS_LIST_SPEC,
+  SESSIONS_READ_SPEC,
+  SESSIONS_RENAME_SPEC,
+  SESSIONS_REWIND_SPEC,
+  SESSIONS_FORK_SPEC,
+  EXTENSIONS_LIST_SPEC,
+  EXTENSIONS_TOGGLE_SPEC,
+  PERMISSIONS_SPEC,
+  CAPABILITIES_SPEC
+];
+
+// src/output/envelope.ts
+var OUTPUT_SCHEMA_VERSION = 1;
+var EXIT_BUSINESS_FAILURE = 1;
+var EXIT_USAGE_ERROR = 2;
+function buildEnvelope(kind, options) {
+  const envelope = {
+    v: OUTPUT_SCHEMA_VERSION,
+    ok: options.ok !== false,
+    kind
+  };
+  if (options.data !== void 0) envelope.data = options.data;
+  if (options.meta && Object.keys(options.meta).length > 0) envelope.meta = options.meta;
+  if (options.help && options.help.length > 0) envelope.help = options.help;
+  if (options.error) envelope.error = options.error;
+  return JSON.stringify(envelope);
+}
+function successEnvelope(kind, data, meta, help) {
+  const envelope = {
+    v: OUTPUT_SCHEMA_VERSION,
+    ok: true,
+    kind
+  };
+  if (data !== void 0) envelope.data = data;
+  if (meta && Object.keys(meta).length > 0) envelope.meta = meta;
+  if (help && help.length > 0) envelope.help = help;
+  return JSON.stringify(envelope);
+}
+function errorEnvelope(kind, code, message, hint) {
+  const envelope = {
+    v: OUTPUT_SCHEMA_VERSION,
+    ok: false,
+    kind,
+    error: {
+      code,
+      message,
+      ...hint ? { hint } : {}
+    }
+  };
+  return JSON.stringify(envelope);
+}
+function printSuccessEnvelope(kind, data, meta, help) {
+  process.stdout.write(`${successEnvelope(kind, data, meta, help)}
+`);
+}
+var CommandError = class extends Error {
+  kind;
+  code;
+  usage;
+  hint;
+  constructor(kind, code, message, options = {}) {
+    super(message);
+    this.name = "CommandError";
+    this.kind = kind;
+    this.code = code;
+    this.usage = options.usage === true;
+    this.hint = options.hint;
+  }
+};
+function isCommandError(value) {
+  return value instanceof CommandError;
+}
+function emitCommandError(error, options) {
+  const commandError = isCommandError(error) ? error : new CommandError(options.fallbackKind, "internal_error", error instanceof Error ? error.message : String(error));
+  if (options.json) {
+    process.stdout.write(`${errorEnvelope(commandError.kind, commandError.code, commandError.message, commandError.hint)}
+`);
+  } else {
+    console.error(commandError.message);
+    if (commandError.hint) {
+      console.error(`Hint: ${commandError.hint}`);
+    }
+  }
+  process.exitCode = commandError.usage ? EXIT_USAGE_ERROR : EXIT_BUSINESS_FAILURE;
+}
+function truncateText(text, maxChars) {
+  const chars = Array.from(text);
+  if (chars.length <= maxChars) {
+    return { text, truncated: false, fullLength: chars.length };
+  }
+  return { text: chars.slice(0, maxChars).join(""), truncated: true, fullLength: chars.length };
+}
+
+// src/capabilities.ts
+function buildCapabilitiesReport() {
+  return {
+    name: "pie",
+    version: VERSION,
+    outputSchemaVersion: OUTPUT_SCHEMA_VERSION,
+    outputFormats: ["human", "json"],
+    exitCodes: { success: 0, businessFailure: 1, usageError: 2 },
+    commands: MANAGEMENT_COMMAND_SPECS.map((spec) => ({
+      path: spec.path,
+      summary: spec.summary,
+      flags: spec.flags.map((flag) => ({
+        name: flag.name,
+        kind: flag.kind,
+        description: flag.description
+      })),
+      positional: spec.positional.map((slot) => ({
+        name: slot.name,
+        required: slot.required,
+        ...slot.variadic ? { variadic: true } : {},
+        description: slot.description
+      }))
+    }))
+  };
+}
+function formatCapabilitiesHelp(report) {
+  const lines = [
+    `pie ${report.version} capabilities`,
+    `output schema: v${report.outputSchemaVersion} (formats: ${report.outputFormats.join(", ")})`,
+    `exit codes: ${report.exitCodes.success} success, ${report.exitCodes.businessFailure} business failure, ${report.exitCodes.usageError} usage error`,
+    "",
+    "Commands:"
+  ];
+  for (const command of report.commands) {
+    lines.push(`  pie ${command.path}  ${command.summary}`);
+  }
+  lines.push("", "Per-command flags: pie <command> --help");
+  return lines.join("\n");
+}
+
+// src/commands/management.ts
+function emitTopLevelUsageError(kind, code, message, args) {
+  emitCommandError(new CommandError(kind, code, message, { usage: true }), {
+    json: args.includes("--json"),
+    fallbackKind: kind
+  });
+}
+async function runDoctorCommand(args) {
+  const parsed = parseCommandArgs(args, DOCTOR_SPEC);
+  if (parsed.error) {
+    emitTopLevelUsageError("doctor", parsed.error.code, parsed.error.message, args);
+    return;
+  }
+  if (parsed.help) {
+    console.log(renderCommandHelp(DOCTOR_SPEC));
+    return;
+  }
+  const json = getFlagBool(parsed, "--json");
+  const report = await runDoctor();
+  if (json) {
+    process.stdout.write(`${buildEnvelope("doctor", {
+      ok: report.ok,
+      data: { summary: report.summary, checks: report.checks },
+      ...report.ok ? {} : { error: { code: "doctor_failed", message: `${report.summary.fail} check(s) failed. Run pie doctor for details.` } }
+    })}
+`);
+  } else {
+    console.log(formatDoctorReport(report));
+  }
+  if (!report.ok) {
+    process.exitCode = EXIT_BUSINESS_FAILURE;
+  }
+}
+function printModelsUsage() {
+  console.log(`Usage:
+  pie models init [--path <path>] [--force] [--stdout] [--json]
+  pie models validate [--path <path>] [--probe web_search] [--json]`);
+}
+async function runModelsCommand(args) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    printModelsUsage();
+    return;
+  }
+  const rest = args.slice(1);
+  if (subcommand === "init") {
+    await runModelsInit(rest, args);
+    return;
+  }
+  if (subcommand === "validate") {
+    await runModelsValidate(rest, args);
+    return;
+  }
+  emitTopLevelUsageError("models", "unknown_command", `Unknown models command: ${subcommand}`, args);
+}
+async function runModelsInit(rest, allArgs) {
+  const parsed = parseCommandArgs(rest, MODELS_INIT_SPEC);
+  if (parsed.error) {
+    emitTopLevelUsageError("models.init", parsed.error.code, `${parsed.error.message}
+${renderCommandUsage(MODELS_INIT_SPEC)}`, allArgs);
+    return;
+  }
+  if (parsed.help) {
+    console.log(renderCommandHelp(MODELS_INIT_SPEC));
+    return;
+  }
+  const json = getFlagBool(parsed, "--json");
+  try {
+    const result = initModelsConfig({
+      path: getFlagString(parsed, "--path"),
+      force: getFlagBool(parsed, "--force"),
+      stdout: getFlagBool(parsed, "--stdout")
+    });
+    if (getFlagBool(parsed, "--stdout")) {
+      process.stdout.write(result.content);
+      return;
+    }
+    if (json) {
+      printSuccessEnvelope("models.init", { path: result.path, wrote: result.wrote });
+    } else {
+      console.log(`Wrote models.json template: ${result.path}`);
+    }
+  } catch (error) {
+    emitCommandError(error, { json, fallbackKind: "models.init" });
+  }
+}
+async function runModelsValidate(rest, allArgs) {
+  const parsed = parseCommandArgs(rest, MODELS_VALIDATE_SPEC);
+  if (parsed.error) {
+    emitTopLevelUsageError("models.validate", parsed.error.code, `${parsed.error.message}
+${renderCommandUsage(MODELS_VALIDATE_SPEC)}`, allArgs);
+    return;
+  }
+  if (parsed.help) {
+    console.log(renderCommandHelp(MODELS_VALIDATE_SPEC));
+    return;
+  }
+  const json = getFlagBool(parsed, "--json");
+  const probePurpose = getFlagString(parsed, "--probe");
+  const result = validateModelsConfig({ path: getFlagString(parsed, "--path") });
+  const probe = result.ok && probePurpose ? await probeModelsConfig({ path: getFlagString(parsed, "--path"), probe: probePurpose }) : void 0;
+  if (json) {
+    const { ok: _ok, ...fields } = result;
+    process.stdout.write(`${buildEnvelope("models.validate", {
+      ok: result.ok && probe?.status !== "failed",
+      data: { ...fields, ...probe ? { probe } : {} },
+      ...result.ok ? {} : { error: { code: "models_invalid", message: result.message } },
+      ...probe?.status === "failed" ? { error: { code: "probe_failed", message: probe.message } } : {}
+    })}
+`);
+    if (!result.ok || probe?.status === "failed") process.exitCode = EXIT_BUSINESS_FAILURE;
+    return;
+  }
+  if (!result.ok) {
+    console.error(result.message);
+    process.exitCode = EXIT_BUSINESS_FAILURE;
+    return;
+  }
+  console.log(result.message);
+  if (result.profiles.length > 0) {
+    console.log(`Profiles: ${result.profiles.join(", ")}`);
+    console.log(`Models: ${result.modelCount}`);
+  }
+  if (result.defaultModel) {
+    console.log(`Default: ${result.defaultModel}`);
+  }
+  if (result.modelClasses && result.modelClasses.length > 0) {
+    console.log(`Model classes: ${result.modelClasses.join(", ")}`);
+  }
+  if (result.webSearchModels && result.webSearchModels.length > 0) {
+    console.log(`Web search: ${result.webSearchModels.join(", ")}`);
+  }
+  if (result.webSearchRouteCandidates && result.webSearchRouteCandidates.length > 0) {
+    console.log(`Web search routes: ${result.webSearchRouteCandidates.join(", ")}`);
+  }
+  if (result.fileCapabilityModels && result.fileCapabilityModels.length > 0) {
+    console.log(`File capabilities: ${result.fileCapabilityModels.join(", ")}`);
+  }
+  if (result.toolModelRoutes && result.toolModelRoutes.length > 0) {
+    console.log(`Tool model routes: ${result.toolModelRoutes.join(", ")}`);
+  }
+  if (probePurpose) {
+    const probeReport = probe ?? await probeModelsConfig({ path: getFlagString(parsed, "--path"), probe: probePurpose });
+    console.log(`Probe ${probeReport.purpose}: ${probeReport.message}`);
+    for (const attempt of probeReport.attempts) {
+      console.log(`- ${attempt.status} ${attempt.route} sources=${attempt.sourceCount}${attempt.failureCategory ? ` failure=${attempt.failureCategory}` : ""}`);
     }
+    if (probeReport.status === "failed") process.exitCode = EXIT_BUSINESS_FAILURE;
+  }
+}
+function runPermissionsCommand(args) {
+  const parsed = parseCommandArgs(args, PERMISSIONS_SPEC);
+  if (parsed.error) {
+    emitTopLevelUsageError("permissions", parsed.error.code, parsed.error.message, args);
+    return;
+  }
+  if (parsed.help) {
+    console.log(renderCommandHelp(PERMISSIONS_SPEC));
+    return;
+  }
+  if (getFlagBool(parsed, "--json")) {
+    printSuccessEnvelope("permissions", buildPermissionsData());
+    return;
   }
-  return parsed;
+  console.log(formatPermissionsHelp());
+}
+function runCapabilitiesCommand(args) {
+  const parsed = parseCommandArgs(args, CAPABILITIES_SPEC);
+  if (parsed.error) {
+    emitTopLevelUsageError("capabilities", parsed.error.code, parsed.error.message, args);
+    return;
+  }
+  if (parsed.help) {
+    console.log(renderCommandHelp(CAPABILITIES_SPEC));
+    return;
+  }
+  const report = buildCapabilitiesReport();
+  if (getFlagBool(parsed, "--json")) {
+    printSuccessEnvelope("capabilities", report, void 0, ["try: pie sessions list --json"]);
+    return;
+  }
+  console.log(formatCapabilitiesHelp(report));
 }
 
 // src/commands/sessions.ts
@@ -47097,7 +47816,7 @@ async function loadRequiredSession(store, sessionId) {
 async function rewindStoredSession(params) {
   const data = await loadRequiredSession(params.store, params.sessionId);
   if (!data.entries.some((entry) => entry.id === params.entryId)) {
-    throw new SessionControlError("checkpoint_not_found", `Entry not found: ${params.entryId}`);
+    throw new SessionControlError("entry_not_found", `Entry not found: ${params.entryId}`);
   }
   try {
     await params.store.save(params.sessionId, data.entries, {
@@ -47112,9 +47831,7 @@ async function rewindStoredSession(params) {
     return {
       sessionId: params.sessionId,
       entryId: params.entryId,
-      checkpointId: params.entryId,
       activeEntryId: params.entryId,
-      headEntryId: params.entryId,
       metadata
     };
   } catch (error) {
@@ -47124,12 +47841,14 @@ async function rewindStoredSession(params) {
 }
 async function forkStoredSession(params) {
   try {
-    const existingTarget = await maybeLoadExistingForkTarget(params);
-    if (existingTarget) return existingTarget;
+    if (!params.force) {
+      const existingTarget = await maybeLoadExistingForkTarget(params);
+      if (existingTarget) return existingTarget;
+    }
     const source = await loadRequiredSession(params.store, params.sourceSessionId);
     const pathEntries = pathToEntry(source, params.sourceEntryId);
     if (pathEntries.length === 0 || pathEntries[pathEntries.length - 1]?.id !== params.sourceEntryId) {
-      throw new SessionControlError("checkpoint_not_found", `Entry not found: ${params.sourceEntryId}`);
+      throw new SessionControlError("entry_not_found", `Entry not found: ${params.sourceEntryId}`);
     }
     const now = params.now ?? Date.now();
     const idMap = /* @__PURE__ */ new Map();
@@ -47202,11 +47921,8 @@ function buildForkResult(params) {
   return {
     sourceSessionId: params.sourceSessionId,
     sourceEntryId: params.sourceEntryId,
-    sourceCheckpointId: params.sourceEntryId,
     targetSessionId: params.metadata.id,
     targetActiveEntryId,
-    targetHeadEntryId: targetActiveEntryId,
-    headEntryId: targetActiveEntryId,
     sourceActiveEntryId: params.sourceActiveEntryId,
     forkBaseEntryId,
     metadata: params.metadata
@@ -47229,238 +47945,312 @@ function cloneJson(value) {
 }
 
 // src/commands/sessions.ts
+var NAME_MAX_CHARS = 24;
+var CONTENT_MAX_CHARS = 80;
+var LIST_ROW_EXTRA_FIELDS = [
+  "createdAt",
+  "cwd",
+  "activeEntryId",
+  "rootEntryId",
+  "sourceSessionId",
+  "sourceEntryId",
+  "sourceActiveEntryId",
+  "forkBaseEntryId"
+];
+var READ_EVENT_EXTRA_FIELDS = ["timestamp", "turnId", "message"];
+var SUBCOMMANDS = {
+  list: { spec: SESSIONS_LIST_SPEC, kind: "sessions.list", run: listSessions },
+  read: { spec: SESSIONS_READ_SPEC, kind: "sessions.read", run: readSession },
+  rename: { spec: SESSIONS_RENAME_SPEC, kind: "sessions.rename", run: renameSession },
+  rewind: { spec: SESSIONS_REWIND_SPEC, kind: "sessions.rewind", run: rewindSession },
+  fork: { spec: SESSIONS_FORK_SPEC, kind: "sessions.fork", run: forkSession }
+};
 async function runSessionsCommand(args) {
-  const command = args[0] || "help";
-  const rest = args.slice(1);
+  const first = args[0];
+  if (!first || first === "help" || first === "--help" || first === "-h") {
+    printSessionsUsage();
+    return;
+  }
+  const entry = SUBCOMMANDS[first];
   try {
-    if (command === "list") {
-      await listSessions(rest);
-      return;
-    }
-    if (command === "read") {
-      await readSession(rest);
-      return;
-    }
-    if (command === "rename") {
-      await renameSession(rest);
-      return;
-    }
-    if (command === "rewind") {
-      await rewindSession(rest);
-      return;
+    if (!entry) {
+      throw new CommandError("sessions", "unknown_command", `Unknown sessions command: ${first}`, {
+        usage: true,
+        hint: "subcommands: list, read, rename, rewind, fork"
+      });
     }
-    if (command === "fork") {
-      await forkSession(rest);
-      return;
+    const parsed = parseCommandArgs(args.slice(1), entry.spec);
+    if (parsed.error) {
+      throw new CommandError(entry.kind, parsed.error.code, `${parsed.error.message}
+${renderCommandUsage(entry.spec)}`, { usage: true });
     }
-    if (command === "help" || command === "--help" || command === "-h") {
-      printSessionsUsage();
+    if (parsed.help) {
+      console.log(renderCommandHelp(entry.spec));
       return;
     }
-    throw new Error(`Unknown sessions command: ${command}`);
+    await entry.run(parsed);
   } catch (error) {
-    if (hasFlag(args, "--json")) {
-      console.log(JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) }));
-    } else {
-      console.error(error instanceof Error ? error.message : String(error));
-    }
-    process.exitCode = 1;
+    const mapped = toSessionCommandError(error, entry?.kind ?? "sessions");
+    emitCommandError(mapped, { json: args.includes("--json"), fallbackKind: entry?.kind ?? "sessions" });
   }
 }
-async function listSessions(args) {
-  const json = hasFlag(args, "--json");
-  const limit = numericFlag(args, "--limit", 50);
-  const cwd = stringFlag(args, "--cwd");
-  const cursor = stringFlag(args, "--cursor");
+function toSessionCommandError(error, kind) {
+  if (error instanceof SessionControlError) {
+    const hints = {
+      session_not_found: "list sessions: pie sessions list --json",
+      target_exists: "choose a new --target, or add --force to overwrite"
+    };
+    return new CommandError(kind, error.code, error.message, { hint: hints[error.code] });
+  }
+  return error;
+}
+async function listSessions(parsed) {
+  const json = getFlagBool(parsed, "--json");
+  const all = getFlagBool(parsed, "--all");
+  const cwdFlag = getFlagString(parsed, "--cwd");
+  const limit = parseLimitFlag(parsed, "sessions.list", 50);
+  const cursor = getFlagString(parsed, "--cursor");
+  const fields = parseExtraFields(getFlagString(parsed, "--fields"), LIST_ROW_EXTRA_FIELDS, "sessions.list");
+  const full = getFlagBool(parsed, "--full");
+  const cwdFilter = cwdFlag ?? (json && !all ? process.cwd() : void 0);
   const store = new FileSessionStore(getSessionsDir());
   const cursorState = decodeListCursor(cursor);
-  const queryKey = listCursorQueryKey({ cwd });
+  const queryKey = listCursorQueryKey({ cwd: cwdFilter });
   const after = cursorState.q === queryKey ? cursorState.after : void 0;
-  const page = await store.listMetadataPage({
-    limit,
-    after,
-    filter: (metadata) => !cwd || cwdMatches(typeof metadata.cwd === "string" ? metadata.cwd : void 0, cwd)
-  });
-  const sessions = page.metadata.map(sessionSummary);
-  const hasMore = page.hasMore;
-  const lastSession = sessions.at(-1);
-  const nextCursor = hasMore && lastSession ? encodeListCursor({ v: 2, q: queryKey, after: { updatedAt: lastSession.updatedAt, id: lastSession.id } }) : void 0;
-  if (json) {
-    console.log(JSON.stringify({ ok: true, sessions, hasMore, nextCursor }, null, 2));
-    return;
-  }
-  if (sessions.length === 0) {
-    console.log("No sessions.");
+  const matchesCwd = cwdFilter ? (metadata) => cwdMatches(typeof metadata.cwd === "string" ? metadata.cwd : void 0, cwdFilter) : void 0;
+  const page = await store.listMetadataPage({ limit, after, filter: matchesCwd });
+  if (!json) {
+    if (page.metadata.length === 0) {
+      console.log("No sessions.");
+      return;
+    }
+    for (const session of page.metadata) {
+      console.log(`${session.id}	${session.name}	${new Date(session.updatedAt).toISOString()}${session.cwd ? `	${session.cwd}` : ""}`);
+    }
     return;
   }
-  for (const session of sessions) {
-    console.log(`${session.id}	${session.name}	${new Date(session.updatedAt).toISOString()}${session.cwd ? `	${session.cwd}` : ""}`);
+  const rows = page.metadata.map((metadata) => listRow(metadata, fields, full));
+  const hasMore = page.hasMore;
+  const lastSession = page.metadata.at(-1);
+  const nextCursor = hasMore && lastSession ? encodeListCursor({ v: 2, q: queryKey, after: { updatedAt: lastSession.updatedAt, id: lastSession.id } }) : void 0;
+  const total = matchesCwd ? (await store.listMetadata()).filter(matchesCwd).length : (await store.listMetadata()).length;
+  const meta = {
+    count: rows.length,
+    total,
+    hasMore,
+    scope: cwdFilter ? "cwd" : "all",
+    ...cwdFilter ? { cwd: cwdFilter } : {},
+    ...nextCursor ? { nextCursor } : {}
+  };
+  const help = [];
+  if (nextCursor) help.push("next page: pass meta.nextCursor to --cursor");
+  if (rows.some((row) => row.truncated === true)) help.push("full names: add --full");
+  if (cwdFilter) help.push("all projects: add --all");
+  if (rows.length === 0) help.push("sessions are created by running pie chat in a project directory");
+  else if (!nextCursor) help.push("open a session: pie sessions read <id> --json");
+  printSuccessEnvelope("sessions.list", rows, meta, help.slice(0, 3));
+}
+function listRow(metadata, fields, full) {
+  const name = full ? { text: metadata.name, truncated: false } : truncateText(metadata.name, NAME_MAX_CHARS);
+  const row = {
+    id: metadata.id,
+    name: name.text,
+    updatedAt: metadata.updatedAt,
+    count: metadata.entryCount
+  };
+  if (name.truncated) row.truncated = true;
+  const optional = {
+    createdAt: metadata.createdAt,
+    cwd: typeof metadata.cwd === "string" ? metadata.cwd : void 0,
+    activeEntryId: metadata.activeEntryId ?? void 0,
+    rootEntryId: metadata.rootEntryId ?? void 0,
+    sourceSessionId: typeof metadata.sourceSessionId === "string" ? metadata.sourceSessionId : void 0,
+    sourceEntryId: typeof metadata.sourceEntryId === "string" ? metadata.sourceEntryId : void 0,
+    sourceActiveEntryId: typeof metadata.sourceActiveEntryId === "string" ? metadata.sourceActiveEntryId : void 0,
+    forkBaseEntryId: typeof metadata.forkBaseEntryId === "string" ? metadata.forkBaseEntryId : void 0
+  };
+  for (const field of fields) {
+    const value = optional[field];
+    if (value !== void 0) row[field] = value;
+  }
+  return row;
+}
+async function readSession(parsed) {
+  const json = getFlagBool(parsed, "--json");
+  const limit = parseLimitFlag(parsed, "sessions.read", 200);
+  const before = getFlagString(parsed, "--before");
+  const fields = parseExtraFields(getFlagString(parsed, "--fields"), READ_EVENT_EXTRA_FIELDS, "sessions.read");
+  const full = getFlagBool(parsed, "--full");
+  const sessionId = getPositional(parsed, "sessionId");
+  if (!sessionId) {
+    throw new CommandError("sessions.read", "missing_positional", renderCommandUsage(SESSIONS_READ_SPEC), { usage: true });
   }
-}
-async function readSession(args) {
-  const json = hasFlag(args, "--json");
-  const includeMessage = hasFlag(args, "--raw") || hasFlag(args, "--include-message");
-  const sessionId = positionalArgs(args, /* @__PURE__ */ new Set(["--limit", "--before"]))[0];
-  if (!sessionId) throw new Error("Usage: pie sessions read <sessionId> [--json] [--raw|--include-message] [--limit <n>] [--before <cursor>]");
-  const limit = numericFlag(args, "--limit", 200);
-  const before = stringFlag(args, "--before");
   const store = new FileSessionStore(getSessionsDir());
-  const data = await store.load(sessionId);
-  if (!data) throw new Error(`Session not found: ${sessionId}`);
+  const data = await loadSession(store, sessionId, "sessions.read");
   const events = activeTranscriptEvents(activePathEntries(data));
   const end = resolveBeforeCursor(events, before);
   const start = Math.max(0, end - limit);
   const page = events.slice(start, end);
-  const response = {
-    ok: true,
-    session: sessionSummary(data.metadata),
-    currentHead: data.metadata.activeEntryId,
+  if (!json) {
+    console.log(`${data.metadata.id}: ${data.metadata.name}`);
+    for (const entry of page) {
+      console.log(`${entry.logicalSeq}	${entry.type}${entry.role ? `:${entry.role}` : ""}	${entry.content ?? ""}`);
+    }
+    return;
+  }
+  const rows = page.map((event) => readEventRow(event, fields, full));
+  const meta = {
+    count: rows.length,
     activeEntryId: data.metadata.activeEntryId,
-    events: json && !includeMessage ? page.map(stableTranscriptEvent) : page,
     hasMoreBefore: start > 0,
-    nextBefore: start > 0 ? String(start) : void 0
+    ...start > 0 ? { nextBefore: String(start) } : {}
   };
-  if (json) {
-    console.log(JSON.stringify(response, null, 2));
-    return;
-  }
-  console.log(`${response.session.id}: ${response.session.name}`);
-  for (const entry of page) {
-    console.log(`${entry.logicalSeq}	${entry.type}${entry.role ? `:${entry.role}` : ""}	${entry.content ?? ""}`);
+  const help = [];
+  if (start > 0) help.push("earlier events: pass meta.nextBefore to --before");
+  if (rows.some((row) => row.truncated === true)) help.push("full content: add --full or --fields message");
+  printSuccessEnvelope("sessions.read", { session: fullSessionRow(data.metadata), events: rows }, meta, help);
+}
+function readEventRow(event, fields, full) {
+  const row = {
+    seq: event.logicalSeq,
+    entryId: event.entryId,
+    type: event.type
+  };
+  if (event.role) row.role = event.role;
+  if (event.content !== void 0) {
+    if (full) {
+      row.content = event.content;
+    } else {
+      const content = truncateText(event.content, CONTENT_MAX_CHARS);
+      row.content = content.text;
+      if (content.truncated) row.truncated = true;
+    }
   }
+  if (fields.includes("timestamp")) row.timestamp = event.timestamp;
+  if (fields.includes("turnId") && event.turnId) row.turnId = event.turnId;
+  if (fields.includes("message") && event.message !== void 0) row.message = event.message;
+  return row;
 }
-async function renameSession(args) {
-  const json = hasFlag(args, "--json");
-  const cwd = stringFlag(args, "--cwd");
-  const positionals = positionalArgs(args, /* @__PURE__ */ new Set(["--cwd"]));
-  const sessionId = positionals[0];
-  const name = positionals.slice(1).join(" ").trim();
-  if (!sessionId || !name) throw new Error("Usage: pie sessions rename <sessionId> <name> [--json] [--cwd <path>]");
+async function renameSession(parsed) {
+  const json = getFlagBool(parsed, "--json");
+  const cwd = getFlagString(parsed, "--cwd");
+  const sessionId = getPositional(parsed, "sessionId");
+  const name = getPositionals(parsed, "name").join(" ").trim();
+  if (!sessionId || !name) {
+    throw new CommandError("sessions.rename", "missing_positional", renderCommandUsage(SESSIONS_RENAME_SPEC), { usage: true });
+  }
   const store = new FileSessionStore(getSessionsDir());
-  const data = await store.load(sessionId);
-  if (!data) throw new Error(`Session not found: ${sessionId}`);
+  const data = await loadSession(store, sessionId, "sessions.rename");
   await store.save(sessionId, data.entries, { ...data.metadata, name, nameSource: "manual", ...cwd ? { cwd } : {}, updatedAt: Date.now() });
   const updated = await store.getMetadata(sessionId);
-  if (!updated) throw new Error(`Session not found after rename: ${sessionId}`);
-  const response = { ok: true, session: sessionSummary(updated) };
+  if (!updated) throw new CommandError("sessions.rename", "session_not_found", `Session not found after rename: ${sessionId}`);
   if (json) {
-    console.log(JSON.stringify(response, null, 2));
+    printSuccessEnvelope("sessions.rename", { session: fullSessionRow(updated) });
     return;
   }
   console.log(`Renamed ${sessionId} to "${name}".`);
 }
-async function rewindSession(args) {
-  const json = hasFlag(args, "--json");
-  const sessionId = positionalArgs(args, /* @__PURE__ */ new Set(["--to"]))[0];
-  const entryId = stringFlag(args, "--to");
-  if (!sessionId || !entryId) throw new Error("Usage: pie sessions rewind <sessionId> --to <entryId> [--json]");
+async function rewindSession(parsed) {
+  const json = getFlagBool(parsed, "--json");
+  const sessionId = getPositional(parsed, "sessionId");
+  const entryId = getFlagString(parsed, "--to");
+  if (!sessionId || !entryId) {
+    throw new CommandError("sessions.rewind", "missing_positional", renderCommandUsage(SESSIONS_REWIND_SPEC), { usage: true });
+  }
   const store = new FileSessionStore(getSessionsDir());
   const result = await rewindStoredSession({ store, sessionId, entryId });
-  const response = {
-    ok: true,
-    session: sessionSummary(result.metadata),
-    activeEntryId: result.activeEntryId,
-    currentHead: result.headEntryId
-  };
   if (json) {
-    console.log(JSON.stringify(response, null, 2));
+    printSuccessEnvelope("sessions.rewind", {
+      session: fullSessionRow(result.metadata),
+      activeEntryId: result.activeEntryId
+    });
     return;
   }
   console.log(`Rewound ${sessionId} to ${entryId}.`);
 }
-async function forkSession(args) {
-  const json = hasFlag(args, "--json");
-  const sourceSessionId = positionalArgs(args, /* @__PURE__ */ new Set(["--from", "--target", "--name", "--cwd"]))[0];
-  const sourceEntryId = stringFlag(args, "--from");
-  const targetSessionId = stringFlag(args, "--target");
-  const name = stringFlag(args, "--name");
-  const cwd = stringFlag(args, "--cwd");
-  if (!sourceSessionId || !sourceEntryId || !targetSessionId || !name) {
-    throw new Error("Usage: pie sessions fork <sessionId> --from <entryId> --target <newSessionId> --name <name> [--cwd <path>] [--json]");
+async function forkSession(parsed) {
+  const json = getFlagBool(parsed, "--json");
+  const sessionId = getPositional(parsed, "sessionId");
+  const sourceEntryId = getFlagString(parsed, "--from");
+  const targetSessionId = getFlagString(parsed, "--target");
+  const name = getFlagString(parsed, "--name");
+  const cwd = getFlagString(parsed, "--cwd");
+  const force = getFlagBool(parsed, "--force");
+  if (!sessionId || !sourceEntryId || !targetSessionId || !name) {
+    throw new CommandError("sessions.fork", "missing_positional", renderCommandUsage(SESSIONS_FORK_SPEC), { usage: true });
   }
   const store = new FileSessionStore(getSessionsDir());
   const result = await forkStoredSession({
     store,
-    sourceSessionId,
+    sourceSessionId: sessionId,
     sourceEntryId,
     targetSessionId,
     name,
-    cwd
+    cwd,
+    force
   });
-  const response = {
-    ok: true,
-    session: sessionSummary(result.metadata),
-    sourceSessionId,
-    sourceEntryId,
-    sourceActiveEntryId: result.sourceActiveEntryId,
-    forkBaseEntryId: result.forkBaseEntryId,
-    activeEntryId: result.targetActiveEntryId,
-    currentHead: result.targetHeadEntryId
-  };
   if (json) {
-    console.log(JSON.stringify(response, null, 2));
+    printSuccessEnvelope("sessions.fork", {
+      session: fullSessionRow(result.metadata),
+      sourceSessionId: result.sourceSessionId,
+      sourceEntryId: result.sourceEntryId,
+      activeEntryId: result.targetActiveEntryId,
+      forkBaseEntryId: result.forkBaseEntryId
+    });
     return;
   }
-  console.log(`Forked ${sourceSessionId} at ${sourceEntryId} into ${targetSessionId}.`);
-}
-function printSessionsUsage() {
-  console.log(`Usage:
-  pie sessions list [--json] [--limit <n>] [--cursor <cursor>] [--cwd <path>]
-  pie sessions read <sessionId> [--json] [--raw|--include-message] [--limit <n>] [--before <cursor>]
-  pie sessions rename <sessionId> <name> [--json] [--cwd <path>]
-  pie sessions rewind <sessionId> --to <entryId> [--json]
-  pie sessions fork <sessionId> --from <entryId> --target <newSessionId> --name <name> [--cwd <path>] [--json]`);
-}
-function hasFlag(args, flag) {
-  return args.includes(flag);
-}
-function stringFlag(args, flag) {
-  const index = args.indexOf(flag);
-  if (index < 0) return void 0;
-  const value = args[index + 1];
-  return value && !value.startsWith("-") ? value : void 0;
-}
-function numericFlag(args, flag, fallback) {
-  const index = args.indexOf(flag);
-  if (index < 0) return fallback;
-  const value = args[index + 1];
-  if (!value) throw new Error(`${flag} requires a value.`);
-  const parsed = Number(value);
-  const max = 1e3;
-  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > max) {
-    throw new Error(`${flag} must be a positive integer no greater than ${max}.`);
-  }
-  return parsed;
+  console.log(`Forked ${sessionId} at ${sourceEntryId} into ${targetSessionId}.`);
 }
-function positionalArgs(args, valueFlags) {
-  const result = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg.startsWith("--")) {
-      if (valueFlags.has(arg)) index += 1;
-      continue;
-    }
-    result.push(arg);
-  }
-  return result;
+async function loadSession(store, sessionId, kind) {
+  const data = await store.load(sessionId);
+  if (!data) throw new CommandError(kind, "session_not_found", `Session not found: ${sessionId}`, { hint: "list sessions: pie sessions list --json" });
+  return data;
 }
-function sessionSummary(metadata) {
+function fullSessionRow(metadata) {
   return {
     id: metadata.id,
     name: metadata.name,
     createdAt: metadata.createdAt,
     updatedAt: metadata.updatedAt,
-    cwd: typeof metadata.cwd === "string" ? metadata.cwd : void 0,
+    ...typeof metadata.cwd === "string" ? { cwd: metadata.cwd } : {},
     entryCount: metadata.entryCount,
-    messageCount: metadata.messageCount,
     activeEntryId: metadata.activeEntryId,
-    rootEntryId: metadata.rootEntryId,
-    sourceSessionId: typeof metadata.sourceSessionId === "string" ? metadata.sourceSessionId : void 0,
-    sourceEntryId: typeof metadata.sourceEntryId === "string" ? metadata.sourceEntryId : void 0,
-    sourceActiveEntryId: typeof metadata.sourceActiveEntryId === "string" ? metadata.sourceActiveEntryId : void 0,
-    forkBaseEntryId: typeof metadata.forkBaseEntryId === "string" ? metadata.forkBaseEntryId : void 0
+    ...typeof metadata.rootEntryId === "string" ? { rootEntryId: metadata.rootEntryId } : {},
+    ...typeof metadata.sourceSessionId === "string" ? { sourceSessionId: metadata.sourceSessionId } : {},
+    ...typeof metadata.sourceEntryId === "string" ? { sourceEntryId: metadata.sourceEntryId } : {},
+    ...typeof metadata.sourceActiveEntryId === "string" ? { sourceActiveEntryId: metadata.sourceActiveEntryId } : {},
+    ...typeof metadata.forkBaseEntryId === "string" ? { forkBaseEntryId: metadata.forkBaseEntryId } : {}
   };
 }
+function parseLimitFlag(parsed, kind, fallback) {
+  const raw = getFlagString(parsed, "--limit");
+  if (raw === void 0) return fallback;
+  const value = Number(raw);
+  const max = 1e3;
+  if (!Number.isInteger(value) || value <= 0 || value > max) {
+    throw new CommandError(kind, "invalid_argument", `--limit must be a positive integer no greater than ${max}.`, { usage: true });
+  }
+  return value;
+}
+function parseExtraFields(raw, allowed, kind) {
+  if (!raw) return [];
+  if (raw === "all") return [...allowed];
+  const requested = raw.split(",").map((value) => value.trim()).filter(Boolean);
+  for (const field of requested) {
+    if (!allowed.includes(field)) {
+      throw new CommandError(kind, "invalid_argument", `Unknown --fields entry: ${field}. Allowed: ${allowed.join(", ")}, all.`, { usage: true });
+    }
+  }
+  return [...new Set(requested)];
+}
+function printSessionsUsage() {
+  console.log(`Usage:
+  pie sessions list [--json] [--limit <n>] [--cursor <cursor>] [--cwd <path> | --all] [--fields <list>] [--full]
+  pie sessions read <sessionId> [--json] [--limit <n>] [--before <cursor>] [--fields <list>] [--full]
+  pie sessions rename <sessionId> <name> [--json] [--cwd <path>]
+  pie sessions rewind <sessionId> --to <entryId> [--json]
+  pie sessions fork <sessionId> --from <entryId> --target <newSessionId> --name <name> [--cwd <path>] [--force] [--json]`);
+}
 function cwdMatches(sessionCwd, requestedCwd) {
   if (!sessionCwd) return false;
   if (sessionCwd === requestedCwd) return true;
@@ -47479,12 +48269,9 @@ function activeTranscriptEvents(entries) {
     const turnId = isRecord2(entry.message) && typeof entry.message.turnId === "string" ? entry.message.turnId : void 0;
     return {
       logicalSeq: index + 1,
-      checkpointId: entry.id,
       entryId: entry.id,
-      id: entry.id,
       type: entry.type,
       timestamp: entry.timestamp,
-      occurredAt: entry.timestamp,
       role,
       turnId,
       content: textFromMessage(entry.message),
@@ -47492,20 +48279,6 @@ function activeTranscriptEvents(entries) {
     };
   });
 }
-function stableTranscriptEvent(event) {
-  return {
-    logicalSeq: event.logicalSeq,
-    checkpointId: event.checkpointId,
-    entryId: event.entryId,
-    id: event.id,
-    type: event.type,
-    timestamp: event.timestamp,
-    occurredAt: event.occurredAt,
-    ...event.role ? { role: event.role } : {},
-    ...event.turnId ? { turnId: event.turnId } : {},
-    ...event.content ? { content: event.content } : {}
-  };
-}
 function activePathEntries(data) {
   const activeEntryId = data.metadata.activeEntryId;
   if (!activeEntryId) return [];
@@ -47517,7 +48290,7 @@ function resolveBeforeCursor(events, cursor) {
   if (Number.isInteger(numeric) && numeric >= 0) {
     return Math.max(0, Math.min(events.length, numeric));
   }
-  const index = events.findIndex((event) => event.entryId === cursor || event.checkpointId === cursor);
+  const index = events.findIndex((event) => event.entryId === cursor);
   return index >= 0 ? index : events.length;
 }
 function cloneJson2(value) {
@@ -48249,31 +49022,7 @@ function parseExtensionFlags(argv) {
 }
 
 // src/commands/extensions.ts
-function parseExtensionsArgs(args) {
-  const extensionPaths = [];
-  let json = false;
-  let scope = "user";
-  let name;
-  const rest = [];
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === "--json") {
-      json = true;
-    } else if (arg === "--project") {
-      scope = "project";
-    } else if (arg === "--user") {
-      scope = "user";
-    } else if (arg === "--extension-path" && args[i + 1]) {
-      extensionPaths.push(args[i + 1]);
-      i += 1;
-    } else if (!name && !arg.startsWith("-")) {
-      name = arg;
-    } else {
-      rest.push(arg);
-    }
-  }
-  return { json, scope, name, extensionPaths, rest };
-}
+var EXTENSION_ROW_EXTRA_FIELDS = ["entryPath", "description"];
 function listExtensions(settingsManager, extensionPaths) {
   const cwd = process.cwd();
   return discoverAllExtensions(
@@ -48294,40 +49043,112 @@ function formatExtensionList(infos) {
   });
   return lines.join("\n");
 }
+function printExtensionsUsage() {
+  console.log(`Usage:
+  pie extensions list [--json] [--extension-path <dir>] [--fields <list>]
+  pie extensions enable <name> [--project|--user] [--json]
+  pie extensions disable <name> [--project|--user] [--json]
+
+Enablement overrides are stored sparsely; absent entries default to enabled.
+Project scope writes ./.pie/settings.json and overrides user scope.`);
+}
 async function runExtensionsCommand(args) {
   const subcommand = args[0] || "list";
-  const parsed = parseExtensionsArgs(args.slice(1));
-  const settingsManager = new SettingsManager();
-  if (subcommand === "list") {
-    const infos = listExtensions(settingsManager, parsed.extensionPaths);
-    if (parsed.json) {
-      console.log(JSON.stringify({ extensions: infos }, null, 2));
+  if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    printExtensionsUsage();
+    return;
+  }
+  const rest = args.slice(1);
+  try {
+    if (subcommand === "list") {
+      await runExtensionsList(rest);
       return;
     }
+    if (subcommand === "enable" || subcommand === "disable") {
+      await runExtensionsToggle(subcommand, rest);
+      return;
+    }
+    throw new CommandError("extensions", "unknown_command", `Unknown extensions command: ${subcommand}`, {
+      usage: true,
+      hint: "subcommands: list, enable, disable"
+    });
+  } catch (error) {
+    emitCommandError(error, { json: args.includes("--json"), fallbackKind: "extensions" });
+  }
+}
+async function runExtensionsList(rest) {
+  const parsed = parseCommandArgs(rest, EXTENSIONS_LIST_SPEC);
+  if (parsed.error) {
+    throw new CommandError("extensions.list", parsed.error.code, parsed.error.message, { usage: true });
+  }
+  if (parsed.help) {
+    console.log(renderCommandHelp(EXTENSIONS_LIST_SPEC));
+    return;
+  }
+  const json = getFlagBool(parsed, "--json");
+  const settingsManager = new SettingsManager();
+  const infos = listExtensions(settingsManager, getFlagStrings(parsed, "--extension-path"));
+  if (!json) {
     console.log(formatExtensionList(infos));
     return;
   }
-  if (subcommand === "enable" || subcommand === "disable") {
-    if (!parsed.name) {
-      console.error(`Usage: pie extensions ${subcommand} <name> [--project|--user]`);
-      process.exitCode = 1;
-      return;
-    }
-    const enabled = subcommand === "enable";
-    settingsManager.setExtensionEnabled(parsed.name, enabled, parsed.scope);
-    const scopeLabel = parsed.scope === "project" ? "./.pie/settings.json" : "~/.pie/settings.json";
-    console.log(
-      `Extension "${parsed.name}" ${enabled ? "enabled" : "disabled"} in ${scopeLabel}. Takes effect on next start.`
-    );
+  const fields = parseExtensionFields(getFlagString(parsed, "--fields"));
+  const rows = infos.map((info) => {
+    const row = {
+      identity: info.identity ?? null,
+      source: info.source,
+      enabled: info.enabled
+    };
+    if (fields.includes("entryPath")) row.entryPath = info.entryPath;
+    if (fields.includes("description") && info.description) row.description = info.description;
+    return row;
+  });
+  printSuccessEnvelope("extensions.list", rows, { count: rows.length, total: rows.length }, [
+    "toggle: pie extensions enable|disable <name>"
+  ]);
+}
+async function runExtensionsToggle(subcommand, rest) {
+  const parsed = parseCommandArgs(rest, EXTENSIONS_TOGGLE_SPEC);
+  if (parsed.error) {
+    throw new CommandError(`extensions.${subcommand}`, parsed.error.code, parsed.error.message, { usage: true });
+  }
+  if (parsed.help) {
+    console.log(renderCommandHelp(EXTENSIONS_TOGGLE_SPEC));
     return;
   }
-  console.log(`Usage:
-  pie extensions list [--json] [--extension-path <dir>]
-  pie extensions enable <name> [--project|--user]
-  pie extensions disable <name> [--project|--user]
-
-Enablement overrides are stored sparsely; absent entries default to enabled.
-Project scope writes ./.pie/settings.json and overrides user scope.`);
+  const json = getFlagBool(parsed, "--json");
+  const name = getPositional(parsed, "name");
+  if (!name) {
+    throw new CommandError(`extensions.${subcommand}`, "missing_positional", `Usage: pie extensions ${subcommand} <name> [--project|--user]`, { usage: true });
+  }
+  const project = getFlagBool(parsed, "--project");
+  const user = getFlagBool(parsed, "--user");
+  if (project && user) {
+    throw new CommandError(`extensions.${subcommand}`, "invalid_argument", "Choose one scope: --project or --user.", { usage: true });
+  }
+  const scope = project ? "project" : "user";
+  const enabled = subcommand === "enable";
+  const settingsManager = new SettingsManager();
+  settingsManager.setExtensionEnabled(name, enabled, scope);
+  if (json) {
+    printSuccessEnvelope(`extensions.${subcommand}`, { identity: name, enabled, scope });
+    return;
+  }
+  const scopeLabel = scope === "project" ? "./.pie/settings.json" : "~/.pie/settings.json";
+  console.log(
+    `Extension "${name}" ${enabled ? "enabled" : "disabled"} in ${scopeLabel}. Takes effect on next start.`
+  );
+}
+function parseExtensionFields(raw) {
+  if (!raw) return [];
+  if (raw === "all") return [...EXTENSION_ROW_EXTRA_FIELDS];
+  const requested = raw.split(",").map((value) => value.trim()).filter(Boolean);
+  for (const field of requested) {
+    if (!EXTENSION_ROW_EXTRA_FIELDS.includes(field)) {
+      throw new CommandError("extensions.list", "invalid_argument", `Unknown --fields entry: ${field}. Allowed: ${EXTENSION_ROW_EXTRA_FIELDS.join(", ")}, all.`, { usage: true });
+    }
+  }
+  return requested;
 }
 
 // src/interactive-mode.ts
@@ -55703,6 +56524,267 @@ function wrapToolsWithExtensions(tools, runner) {
   return tools.map((tool) => wrapToolWithExtensions(tool, runner));
 }
 
+// src/core/defaults.ts
+var DEFAULT_THINKING_LEVEL = "medium";
+
+// src/core/model-resolver.ts
+function normalizeProviderName(provider) {
+  return provider.toLowerCase().replace(/[^a-z]/g, "");
+}
+function selectFallbackModel(registry, preferred) {
+  const availableModels = registry.getAvailable();
+  if (preferred?.provider && preferred?.modelId) {
+    const exact = availableModels.find(
+      (model) => model.provider === preferred.provider && model.id === preferred.modelId
+    );
+    if (exact) return exact;
+  }
+  if (preferred?.provider) {
+    const sameProvider = availableModels.find((model) => model.provider === preferred.provider);
+    if (sameProvider) return sameProvider;
+  }
+  return availableModels[0] || registry.getAll()[0];
+}
+function resolveConfiguredModel(registry, provider, modelId) {
+  const exact = registry.find(provider, modelId);
+  if (exact) {
+    return { model: exact, provider, modelId, corrected: false };
+  }
+  const allModels = registry.getAll();
+  if (allModels.length === 0) {
+    throw new Error("No registered models are available.");
+  }
+  const sameIdMatches = allModels.filter((model) => model.id === modelId);
+  const normalizedProviderMatches = sameIdMatches.filter(
+    (model) => normalizeProviderName(model.provider) === normalizeProviderName(provider)
+  );
+  if (normalizedProviderMatches.length === 1) {
+    const matched = normalizedProviderMatches[0];
+    return {
+      model: matched,
+      provider: matched.provider,
+      modelId: matched.id,
+      corrected: true,
+      warning: `Configured model "${provider}/${modelId}" was not found. Using "${matched.provider}/${matched.id}" instead.`
+    };
+  }
+  if (sameIdMatches.length === 1) {
+    const matched = sameIdMatches[0];
+    return {
+      model: matched,
+      provider: matched.provider,
+      modelId: matched.id,
+      corrected: true,
+      warning: `Configured model "${provider}/${modelId}" was not found. Reusing the available model "${matched.provider}/${matched.id}".`
+    };
+  }
+  const providerModels = registry.getByProvider(provider);
+  if (providerModels.length > 0) {
+    const fallback2 = providerModels[0];
+    return {
+      model: fallback2,
+      provider: fallback2.provider,
+      modelId: fallback2.id,
+      corrected: true,
+      warning: `Configured model "${provider}/${modelId}" was not found. Falling back to "${fallback2.provider}/${fallback2.id}".`
+    };
+  }
+  const fallback = selectFallbackModel(registry);
+  if (!fallback) {
+    throw new Error("No registered models are available.");
+  }
+  return {
+    model: fallback,
+    provider: fallback.provider,
+    modelId: fallback.id,
+    corrected: true,
+    warning: `Configured model "${provider}/${modelId}" was not found. Falling back to "${fallback.provider}/${fallback.id}".`
+  };
+}
+function findInitialModel(options) {
+  const configDefaults = options.registry.getConfigDefaults();
+  const configuredProvider = options.configuredProvider || configDefaults?.provider;
+  const configuredModelId = options.configuredModelId || configDefaults?.modelId;
+  const resolved = configuredProvider && configuredModelId ? resolveConfiguredModel(options.registry, configuredProvider, configuredModelId) : void 0;
+  const apiKey = resolved ? options.registry.getApiKey(resolved.model) : void 0;
+  if (!resolved || !apiKey) {
+    const fallback = selectFallbackModel(options.registry, {
+      provider: configuredProvider,
+      modelId: configuredModelId
+    });
+    if (!fallback) {
+      return {
+        model: void 0,
+        apiKey: void 0,
+        provider: void 0,
+        modelId: void 0,
+        unconfigured: true,
+        warning: "No models are configured. Add one in ~/.pie/models.json before sending messages."
+      };
+    }
+    const fallbackKey = options.registry.getApiKey(fallback);
+    if (!fallbackKey) {
+      throw new Error(`No API key found for provider "${resolved?.provider || fallback.provider}".`);
+    }
+    return {
+      model: fallback,
+      apiKey: fallbackKey,
+      provider: fallback.provider,
+      modelId: fallback.id,
+      warning: resolved ? resolved.warning || `No API key found for "${resolved.provider}". Using "${fallback.provider}/${fallback.id}" instead.` : configuredProvider && configuredModelId ? `Configured model "${configuredProvider}/${configuredModelId}" was not found. Using "${fallback.provider}/${fallback.id}" instead.` : void 0
+    };
+  }
+  return {
+    model: resolved.model,
+    apiKey,
+    provider: resolved.provider,
+    modelId: resolved.modelId,
+    warning: resolved.warning
+  };
+}
+function restoreModelFromSession(options) {
+  const savedProvider = options.savedProvider;
+  const restored = options.registry.find(savedProvider, options.savedModelId);
+  if (restored && options.registry.getApiKey(restored)) {
+    return { model: restored };
+  }
+  if (options.currentModel) {
+    return {
+      model: options.currentModel,
+      fallbackMessage: `Could not restore model ${savedProvider}/${options.savedModelId}. Using ${options.currentModel.provider}/${options.currentModel.id}.`
+    };
+  }
+  const fallback = selectFallbackModel(options.registry, {
+    provider: savedProvider,
+    modelId: options.savedModelId
+  });
+  return fallback ? {
+    model: fallback,
+    fallbackMessage: `Could not restore model ${savedProvider}/${options.savedModelId}. Using ${fallback.provider}/${fallback.id}.`
+  } : { model: void 0 };
+}
+
+// src/core/session-model-metadata.ts
+function getSavedSessionModelSelection(activeSession) {
+  if (!activeSession) return {};
+  const provider = typeof activeSession.metadata.provider === "string" ? activeSession.metadata.provider : typeof activeSession.metadata.defaultProvider === "string" ? activeSession.metadata.defaultProvider : void 0;
+  const modelId = typeof activeSession.metadata.modelId === "string" ? activeSession.metadata.modelId : typeof activeSession.metadata.defaultModel === "string" ? activeSession.metadata.defaultModel : void 0;
+  const thinkingLevel = typeof activeSession.metadata.thinkingLevel === "string" ? activeSession.metadata.thinkingLevel : void 0;
+  return { provider, modelId, thinkingLevel };
+}
+function syncSessionModelMetadata(sessionManager, model, thinkingLevel) {
+  const activeSession = sessionManager.getActiveSession();
+  if (!activeSession || !model) return;
+  activeSession.metadata.provider = model.provider;
+  activeSession.metadata.modelId = model.id;
+  activeSession.metadata.defaultProvider = model.provider;
+  activeSession.metadata.defaultModel = model.id;
+  activeSession.metadata.thinkingLevel = thinkingLevel;
+  activeSession.isDirty = true;
+}
+function restoreSessionModelState(options) {
+  const { provider, modelId, thinkingLevel } = getSavedSessionModelSelection(options.activeSession);
+  if (!provider || !modelId) {
+    return {
+      model: options.currentModel,
+      thinkingLevel
+    };
+  }
+  const restored = restoreModelFromSession({
+    registry: options.registry,
+    savedProvider: provider,
+    savedModelId: modelId,
+    currentModel: options.currentModel
+  });
+  return {
+    model: restored.model,
+    thinkingLevel,
+    fallbackMessage: restored.fallbackMessage
+  };
+}
+
+// src/core/interactive-model-state.ts
+var THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+];
+var THINKING_LEVEL_DESCRIPTIONS = {
+  off: "No reasoning",
+  minimal: "Very brief reasoning (~1k tokens)",
+  low: "Light reasoning (~2k tokens)",
+  medium: "Moderate reasoning (~8k tokens)",
+  high: "Deep reasoning (~16k tokens)",
+  xhigh: "Maximum reasoning (~32k tokens)"
+};
+function isThinkingLevel(value) {
+  return THINKING_LEVELS.includes(value);
+}
+function resolveInitialThinkingLevel(options) {
+  const sessionLevel = options.session?.metadata.thinkingLevel;
+  if (typeof sessionLevel === "string" && isThinkingLevel(sessionLevel)) {
+    return sessionLevel;
+  }
+  return options.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+}
+function maskApiKey(key) {
+  if (key.length <= 6) return "***";
+  return key.slice(0, 6) + "***";
+}
+function applyThinkingLevel(options) {
+  options.agent.setThinkingLevel(options.level);
+  options.settingsManager.setDefaultThinkingLevel(options.level);
+  syncSessionModelMetadata(options.sessionManager, options.model, options.level);
+}
+function switchInteractiveModel(options) {
+  const [provider, modelId] = options.fullModelId.split("/");
+  const model = options.registry.find(provider, modelId);
+  if (!model) {
+    throw new Error(`Model "${options.fullModelId}" not found`);
+  }
+  const apiKey = options.registry.getApiKey(model);
+  options.agent.setModel(model);
+  if (apiKey) {
+    options.agent.apiKey = apiKey;
+    fileLogger.log("cli", `Switched model to ${options.fullModelId}, updated API key`, {
+      keyPrefix: maskApiKey(apiKey)
+    });
+  } else {
+    fileLogger.log("cli", `Switched model to ${options.fullModelId}, no API key found`);
+  }
+  options.settingsManager.setDefaultModelAndProvider(provider, modelId);
+  syncSessionModelMetadata(options.sessionManager, model, options.thinkingLevel);
+  return { model, apiKey };
+}
+function restoreInteractiveSessionState(options) {
+  const restored = restoreSessionModelState({
+    activeSession: options.activeSession,
+    registry: options.registry,
+    currentModel: options.currentModel
+  });
+  const thinkingLevel = restored.thinkingLevel && isThinkingLevel(restored.thinkingLevel) ? restored.thinkingLevel : void 0;
+  if (thinkingLevel) {
+    options.agent.setThinkingLevel(thinkingLevel);
+  }
+  let apiKey;
+  if (restored.model) {
+    options.agent.setModel(restored.model);
+    apiKey = options.registry.getApiKey(restored.model);
+    if (apiKey) {
+      options.agent.apiKey = apiKey;
+    }
+  }
+  return {
+    model: restored.model,
+    apiKey,
+    thinkingLevel,
+    fallbackMessage: restored.fallbackMessage
+  };
+}
+
 // src/keybindings.ts
 import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
 import { join as join7 } from "path";
@@ -56829,23 +57911,23 @@ function parseThemeJson(label, json) {
         otherErrors.push(`  - ${e.path}: ${e.message}`);
       }
     }
-    let errorMessage3 = `Invalid theme "${label}":
+    let errorMessage4 = `Invalid theme "${label}":
 `;
     if (missingColors.length > 0) {
-      errorMessage3 += "\nMissing required color tokens:\n";
-      errorMessage3 += missingColors.map((c) => `  - ${c}`).join("\n");
-      errorMessage3 += `
+      errorMessage4 += "\nMissing required color tokens:\n";
+      errorMessage4 += missingColors.map((c) => `  - ${c}`).join("\n");
+      errorMessage4 += `
 
 Please add these colors to your theme's "colors" object.`;
-      errorMessage3 += "\nSee the built-in themes (dark.json, light.json) for reference values.";
+      errorMessage4 += "\nSee the built-in themes (dark.json, light.json) for reference values.";
     }
     if (otherErrors.length > 0) {
-      errorMessage3 += `
+      errorMessage4 += `
 
 Other errors:
 ${otherErrors.join("\n")}`;
     }
-    throw new Error(errorMessage3);
+    throw new Error(errorMessage4);
   }
   return json;
 }
@@ -61265,257 +62347,6 @@ var SettingsSelectorComponent = class extends Container {
   }
 };
 
-// src/core/model-resolver.ts
-function normalizeProviderName(provider) {
-  return provider.toLowerCase().replace(/[^a-z]/g, "");
-}
-function selectFallbackModel(registry, preferred) {
-  const availableModels = registry.getAvailable();
-  if (preferred?.provider && preferred?.modelId) {
-    const exact = availableModels.find(
-      (model) => model.provider === preferred.provider && model.id === preferred.modelId
-    );
-    if (exact) return exact;
-  }
-  if (preferred?.provider) {
-    const sameProvider = availableModels.find((model) => model.provider === preferred.provider);
-    if (sameProvider) return sameProvider;
-  }
-  return availableModels[0] || registry.getAll()[0];
-}
-function resolveConfiguredModel(registry, provider, modelId) {
-  const exact = registry.find(provider, modelId);
-  if (exact) {
-    return { model: exact, provider, modelId, corrected: false };
-  }
-  const allModels = registry.getAll();
-  if (allModels.length === 0) {
-    throw new Error("No registered models are available.");
-  }
-  const sameIdMatches = allModels.filter((model) => model.id === modelId);
-  const normalizedProviderMatches = sameIdMatches.filter(
-    (model) => normalizeProviderName(model.provider) === normalizeProviderName(provider)
-  );
-  if (normalizedProviderMatches.length === 1) {
-    const matched = normalizedProviderMatches[0];
-    return {
-      model: matched,
-      provider: matched.provider,
-      modelId: matched.id,
-      corrected: true,
-      warning: `Configured model "${provider}/${modelId}" was not found. Using "${matched.provider}/${matched.id}" instead.`
-    };
-  }
-  if (sameIdMatches.length === 1) {
-    const matched = sameIdMatches[0];
-    return {
-      model: matched,
-      provider: matched.provider,
-      modelId: matched.id,
-      corrected: true,
-      warning: `Configured model "${provider}/${modelId}" was not found. Reusing the available model "${matched.provider}/${matched.id}".`
-    };
-  }
-  const providerModels = registry.getByProvider(provider);
-  if (providerModels.length > 0) {
-    const fallback2 = providerModels[0];
-    return {
-      model: fallback2,
-      provider: fallback2.provider,
-      modelId: fallback2.id,
-      corrected: true,
-      warning: `Configured model "${provider}/${modelId}" was not found. Falling back to "${fallback2.provider}/${fallback2.id}".`
-    };
-  }
-  const fallback = selectFallbackModel(registry);
-  if (!fallback) {
-    throw new Error("No registered models are available.");
-  }
-  return {
-    model: fallback,
-    provider: fallback.provider,
-    modelId: fallback.id,
-    corrected: true,
-    warning: `Configured model "${provider}/${modelId}" was not found. Falling back to "${fallback.provider}/${fallback.id}".`
-  };
-}
-function findInitialModel(options) {
-  const configDefaults = options.registry.getConfigDefaults();
-  const configuredProvider = options.configuredProvider || configDefaults?.provider;
-  const configuredModelId = options.configuredModelId || configDefaults?.modelId;
-  const resolved = configuredProvider && configuredModelId ? resolveConfiguredModel(options.registry, configuredProvider, configuredModelId) : void 0;
-  const apiKey = resolved ? options.registry.getApiKey(resolved.model) : void 0;
-  if (!resolved || !apiKey) {
-    const fallback = selectFallbackModel(options.registry, {
-      provider: configuredProvider,
-      modelId: configuredModelId
-    });
-    if (!fallback) {
-      return {
-        model: void 0,
-        apiKey: void 0,
-        provider: void 0,
-        modelId: void 0,
-        unconfigured: true,
-        warning: "No models are configured. Add one in ~/.pie/models.json before sending messages."
-      };
-    }
-    const fallbackKey = options.registry.getApiKey(fallback);
-    if (!fallbackKey) {
-      throw new Error(`No API key found for provider "${resolved?.provider || fallback.provider}".`);
-    }
-    return {
-      model: fallback,
-      apiKey: fallbackKey,
-      provider: fallback.provider,
-      modelId: fallback.id,
-      warning: resolved ? resolved.warning || `No API key found for "${resolved.provider}". Using "${fallback.provider}/${fallback.id}" instead.` : configuredProvider && configuredModelId ? `Configured model "${configuredProvider}/${configuredModelId}" was not found. Using "${fallback.provider}/${fallback.id}" instead.` : void 0
-    };
-  }
-  return {
-    model: resolved.model,
-    apiKey,
-    provider: resolved.provider,
-    modelId: resolved.modelId,
-    warning: resolved.warning
-  };
-}
-function restoreModelFromSession(options) {
-  const savedProvider = options.savedProvider;
-  const restored = options.registry.find(savedProvider, options.savedModelId);
-  if (restored && options.registry.getApiKey(restored)) {
-    return { model: restored };
-  }
-  if (options.currentModel) {
-    return {
-      model: options.currentModel,
-      fallbackMessage: `Could not restore model ${savedProvider}/${options.savedModelId}. Using ${options.currentModel.provider}/${options.currentModel.id}.`
-    };
-  }
-  const fallback = selectFallbackModel(options.registry, {
-    provider: savedProvider,
-    modelId: options.savedModelId
-  });
-  return fallback ? {
-    model: fallback,
-    fallbackMessage: `Could not restore model ${savedProvider}/${options.savedModelId}. Using ${fallback.provider}/${fallback.id}.`
-  } : { model: void 0 };
-}
-
-// src/core/session-model-metadata.ts
-function getSavedSessionModelSelection(activeSession) {
-  if (!activeSession) return {};
-  const provider = typeof activeSession.metadata.provider === "string" ? activeSession.metadata.provider : typeof activeSession.metadata.defaultProvider === "string" ? activeSession.metadata.defaultProvider : void 0;
-  const modelId = typeof activeSession.metadata.modelId === "string" ? activeSession.metadata.modelId : typeof activeSession.metadata.defaultModel === "string" ? activeSession.metadata.defaultModel : void 0;
-  const thinkingLevel = typeof activeSession.metadata.thinkingLevel === "string" ? activeSession.metadata.thinkingLevel : void 0;
-  return { provider, modelId, thinkingLevel };
-}
-function syncSessionModelMetadata(sessionManager, model, thinkingLevel) {
-  const activeSession = sessionManager.getActiveSession();
-  if (!activeSession || !model) return;
-  activeSession.metadata.provider = model.provider;
-  activeSession.metadata.modelId = model.id;
-  activeSession.metadata.defaultProvider = model.provider;
-  activeSession.metadata.defaultModel = model.id;
-  activeSession.metadata.thinkingLevel = thinkingLevel;
-  activeSession.isDirty = true;
-}
-function restoreSessionModelState(options) {
-  const { provider, modelId, thinkingLevel } = getSavedSessionModelSelection(options.activeSession);
-  if (!provider || !modelId) {
-    return {
-      model: options.currentModel,
-      thinkingLevel
-    };
-  }
-  const restored = restoreModelFromSession({
-    registry: options.registry,
-    savedProvider: provider,
-    savedModelId: modelId,
-    currentModel: options.currentModel
-  });
-  return {
-    model: restored.model,
-    thinkingLevel,
-    fallbackMessage: restored.fallbackMessage
-  };
-}
-
-// src/core/interactive-model-state.ts
-var THINKING_LEVELS = [
-  "off",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh"
-];
-var THINKING_LEVEL_DESCRIPTIONS = {
-  off: "No reasoning",
-  minimal: "Very brief reasoning (~1k tokens)",
-  low: "Light reasoning (~2k tokens)",
-  medium: "Moderate reasoning (~8k tokens)",
-  high: "Deep reasoning (~16k tokens)",
-  xhigh: "Maximum reasoning (~32k tokens)"
-};
-function isThinkingLevel(value) {
-  return THINKING_LEVELS.includes(value);
-}
-function maskApiKey(key) {
-  if (key.length <= 6) return "***";
-  return key.slice(0, 6) + "***";
-}
-function applyThinkingLevel(options) {
-  options.agent.setThinkingLevel(options.level);
-  options.settingsManager.setDefaultThinkingLevel(options.level);
-  syncSessionModelMetadata(options.sessionManager, options.model, options.level);
-}
-function switchInteractiveModel(options) {
-  const [provider, modelId] = options.fullModelId.split("/");
-  const model = options.registry.find(provider, modelId);
-  if (!model) {
-    throw new Error(`Model "${options.fullModelId}" not found`);
-  }
-  const apiKey = options.registry.getApiKey(model);
-  options.agent.setModel(model);
-  if (apiKey) {
-    options.agent.apiKey = apiKey;
-    fileLogger.log("cli", `Switched model to ${options.fullModelId}, updated API key`, {
-      keyPrefix: maskApiKey(apiKey)
-    });
-  } else {
-    fileLogger.log("cli", `Switched model to ${options.fullModelId}, no API key found`);
-  }
-  options.settingsManager.setDefaultModelAndProvider(provider, modelId);
-  syncSessionModelMetadata(options.sessionManager, model, options.thinkingLevel);
-  return { model, apiKey };
-}
-function restoreInteractiveSessionState(options) {
-  const restored = restoreSessionModelState({
-    activeSession: options.activeSession,
-    registry: options.registry,
-    currentModel: options.currentModel
-  });
-  const thinkingLevel = restored.thinkingLevel && isThinkingLevel(restored.thinkingLevel) ? restored.thinkingLevel : void 0;
-  if (thinkingLevel) {
-    options.agent.setThinkingLevel(thinkingLevel);
-  }
-  let apiKey;
-  if (restored.model) {
-    options.agent.setModel(restored.model);
-    apiKey = options.registry.getApiKey(restored.model);
-    if (apiKey) {
-      options.agent.apiKey = apiKey;
-    }
-  }
-  return {
-    model: restored.model,
-    apiKey,
-    thinkingLevel,
-    fallbackMessage: restored.fallbackMessage
-  };
-}
-
 // src/core/session-display.ts
 function deriveSessionTitle(options) {
   const { activeSession, messages } = options;
@@ -61833,7 +62664,10 @@ var BUILTIN_SLASH_COMMANDS = [
   { name: "sessions/info", description: "Show session info" },
   { name: "sessions/fork", description: "Fork from a message" },
   { name: "settings", description: "Open settings menu" },
-  { name: "settings/extensions", description: "Manage extensions" },
+  { name: "extensions", description: "Manage extensions (list/enable/disable)" },
+  { name: "extensions/list", description: "List discovered extensions (including disabled)" },
+  { name: "extensions/enable", description: "Enable an extension by identity (writes settings)" },
+  { name: "extensions/disable", description: "Disable an extension by identity (writes settings)" },
   { name: "settings/help", description: "Show help information (keyboard shortcuts and commands)" },
   { name: "settings/hotkeys", description: "Show keyboard shortcuts" },
   { name: "settings/model", description: "Select AI model" },
@@ -61841,14 +62675,19 @@ var BUILTIN_SLASH_COMMANDS = [
   { name: "settings/thinking", description: "Set thinking level" },
   { name: "settings/calm", description: "Toggle calm mode: show only questions and answers" },
   { name: "settings/yolo", description: "Toggle or set YOLO mode" },
-  { name: "settings/debugs/cache-test", description: "Run provider cache diagnostics with a dedicated 2-request probe" },
-  { name: "settings/debugs/context", description: "Append a context summary to ~/.pie/logs/pie-cli.log" },
-  { name: "settings/debugs/package", description: "Append a package summary to ~/.pie/logs/pie-cli.log" },
+  { name: "debugs/cache-test", description: "Run provider cache diagnostics with a dedicated 2-request probe" },
+  { name: "debugs/context", description: "Append a context summary to ~/.pie/logs/pie-cli.log" },
+  { name: "debugs/package", description: "Append a package summary to ~/.pie/logs/pie-cli.log" },
   { name: "settings/quit", description: "Exit Pie" },
   { name: "skills", description: "Open skills menu" },
   { name: "skills/list", description: "List available skills" },
+  { name: "skills/enable", description: "Enable a skill by name" },
+  { name: "skills/disable", description: "Disable a skill by name" },
   { name: "skills/reload", description: "Reload skills from disk" },
   { name: "skills/use", description: "Use a skill" },
+  { name: "tools", description: "List tools and manage enable/disable toggles" },
+  { name: "tools/enable", description: "Enable a tool by name" },
+  { name: "tools/disable", description: "Disable a tool by name" },
   { name: "tools/subagent", description: "Spawn subagents in parallel to handle tasks" }
 ];
 
@@ -63958,7 +64797,7 @@ async function handleResumeCommand(host) {
     return { component: selector, focus: selector.getSelectList() };
   });
 }
-async function loadSession(host, sessionId) {
+async function loadSession2(host, sessionId) {
   const beforeSwitch = await host.extensionRunner?.emitSessionBeforeSwitch({
     type: "session:before_switch",
     reason: "resume",
@@ -64431,6 +65270,14 @@ function handleSkillsCommand(host) {
       host.chatContainer.addChild(new Text(theme.fg("dim", `  \u2022 ${skill.name}: ${skill.description}`), 1, 0));
     }
   }
+  const disabledNames = Object.entries(host.options.settingsManager.getSkillSettings()).filter(([, entry]) => entry === false || entry && typeof entry === "object" && entry.enabled === false).map(([name]) => name).filter((name) => !host.skills.some((skill) => skill.name === name));
+  if (disabledNames.length > 0) {
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new Text(theme.fg("dim", "Disabled skills:"), 1, 0));
+    for (const name of disabledNames) {
+      host.chatContainer.addChild(new Text(theme.fg("dim", `  \u2022 ${name} (disabled; /skills/enable ${name})`), 1, 0));
+    }
+  }
   host.chatContainer.addChild(new Spacer(1));
   host.chatContainer.addChild(new Text(theme.fg("dim", "Usage: /skills/skill:<name> <your request>"), 1, 0));
   host.chatContainer.addChild(new Text(theme.fg("dim", "Example: /skills/skill:browser-tools navigate to google.com"), 1, 0));
@@ -64457,7 +65304,11 @@ function handleSkillCommand(host, name) {
 async function handleSkillInvoke(host, skillName, args) {
   const skill = host.skills.find((s) => s.name === skillName);
   if (!skill) {
-    host.showError(`Skill not found: ${skillName}`);
+    if (!host.options.settingsManager.isSkillEnabled(skillName)) {
+      host.showError(`Skill disabled: ${skillName}. Use /skills/enable ${skillName} to restore it.`);
+    } else {
+      host.showError(`Skill not found: ${skillName}`);
+    }
     return;
   }
   const skillText = `skill:${skillName} ${args}`.trim();
@@ -64541,6 +65392,30 @@ function stripFrontmatter(host, content) {
   }
   return content;
 }
+async function handleSkillToggleCommand(host, args, enabled) {
+  const name = args.trim();
+  if (!name) {
+    host.showError(`Usage: /skills/${enabled ? "enable" : "disable"} <name>`);
+    return;
+  }
+  const builtinDir = path25.join(getBuiltinDir(), "skills");
+  const userDir = path25.join(os7.homedir(), ".pie", "skills");
+  const projectDir = path25.join(process.cwd(), ".pie", "skills");
+  const discovered = loadSkills({ dirs: buildSkillDirs({ builtinDir, userDir, projectDir, cwd: process.cwd() }) }).skills;
+  if (!discovered.some((skill) => skill.name === name)) {
+    host.showError(`Skill not found: ${name}`);
+    return;
+  }
+  try {
+    host.options.settingsManager.setSkillEnabled(name, enabled);
+  } catch (error) {
+    host.showError(`Failed to update skill "${name}": ${errorMessage2(error)}`);
+    return;
+  }
+  await handleSkillsReload(host);
+  host.chatContainer.addChild(new Text(theme.fg("accent", `Skill "${name}" ${enabled ? "enabled" : "disabled"} in ~/.pie/settings.json`), 1, 0));
+  host.ui.requestRender();
+}
 async function handleSkillsCreate(host, args) {
   console.error(`[SkillsCreate] Called with args: "${args}"`);
   try {
@@ -64636,7 +65511,7 @@ async function handleSkillsReload(host) {
     const userDir = path25.join(os7.homedir(), ".pie", "skills");
     const projectDir = path25.join(process.cwd(), ".pie", "skills");
     const result = loadSkills({ dirs: buildSkillDirs({ builtinDir, userDir, projectDir, cwd: process.cwd() }) });
-    host.skills = result.skills;
+    host.skills = result.skills.filter((skill) => host.options.settingsManager.isSkillEnabled(skill.name));
     host.skillsSection = formatSkillsForPrompt(host.skills);
     host.applyRuntimeToolMode(host.allTools.length > 0 ? host.allTools : host.agent.state.tools);
     host.updateSystemPromptTools();
@@ -64671,6 +65546,67 @@ async function handleSkillsReload(host) {
   }
 }
 
+// src/commands/interactive-tools-command.ts
+function errorMessage3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function collectKnownToolNames(host) {
+  const liveNames = (host.allTools.length > 0 ? host.allTools : host.agent?.state.tools ?? []).map((tool) => tool.name);
+  const disabledNames = host.options.settingsManager.getDisabledTools();
+  const disabled = disabledNames.filter((name) => !liveNames.includes(name));
+  return { active: [...liveNames].sort(), disabled: [...disabled].sort() };
+}
+function handleToolsCommand(host, args) {
+  const parts = args.trim().split(/\s+/).filter(Boolean);
+  const subcommand = parts[0];
+  if (subcommand === "enable" || subcommand === "disable") {
+    const name = parts.slice(1).join(" ").trim();
+    if (!name) {
+      host.showError(`Usage: /tools ${subcommand} <tool-name>`);
+      return;
+    }
+    const { active: active2, disabled: disabled2 } = collectKnownToolNames(host);
+    if (!active2.includes(name) && !disabled2.includes(name)) {
+      host.showError(`Tool not found: ${name}. Use /tools to list tool names.`);
+      return;
+    }
+    const enabled = subcommand === "enable";
+    try {
+      host.options.settingsManager.setToolEnabled(name, enabled);
+    } catch (error) {
+      host.showError(`Failed to update tool "${name}": ${errorMessage3(error)}`);
+      return;
+    }
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new Text(
+      theme.fg("accent", `Tool "${name}" ${enabled ? "enabled" : "disabled"} in ~/.pie/settings.json. Takes effect on next start.`),
+      1,
+      0
+    ));
+    host.ui.requestRender();
+    return;
+  }
+  if (subcommand) {
+    host.showError("Usage: /tools [enable|disable <tool-name>]");
+    return;
+  }
+  const { active, disabled } = collectKnownToolNames(host);
+  host.chatContainer.addChild(new Spacer(1));
+  host.chatContainer.addChild(new Text(theme.bold("Tools"), 1, 0));
+  if (active.length === 0 && disabled.length === 0) {
+    host.chatContainer.addChild(new Text(theme.fg("dim", "  No tools available."), 1, 0));
+  }
+  for (const name of active) {
+    host.chatContainer.addChild(new Text(theme.fg("dim", `  \u2022 ${name}: enabled`), 1, 0));
+  }
+  for (const name of disabled) {
+    host.chatContainer.addChild(new Text(theme.fg("dim", `  \u2022 ${name}: disabled (/tools/enable ${name})`), 1, 0));
+  }
+  host.chatContainer.addChild(new Spacer(1));
+  host.chatContainer.addChild(new Text(theme.fg("dim", "Usage: /tools/enable <name> | /tools/disable <name> (takes effect on next start)"), 1, 0));
+  host.ui.requestRender();
+}
+
 // src/commands/interactive-command-handlers.ts
 function showSettingsSelector(host) {
   host.showSelector((done) => {
@@ -65271,19 +66207,19 @@ function registerBuiltinCommands(host) {
     description: "Toggle calm mode: show only questions and answers (on/off/status)",
     handler: (_2, args) => host.handleCalmCommand(args)
   });
-  commandTree.register(["settings", "extensions"], {
+  commandTree.register(["extensions"], {
     description: "List extensions and manage enable/disable toggles",
     handler: (_2, args) => host.handleExtensionsCommand(args)
   });
-  commandTree.register(["settings", "extensions", "list"], {
+  commandTree.register(["extensions", "list"], {
     description: "List discovered extensions (including disabled)",
     handler: (_2, args) => host.handleExtensionsCommand(args ? `list ${args}` : "list")
   });
-  commandTree.register(["settings", "extensions", "enable"], {
+  commandTree.register(["extensions", "enable"], {
     description: "Enable an extension by identity (writes settings)",
     handler: (_2, args) => host.handleExtensionsCommand(`enable ${args || ""}`)
   });
-  commandTree.register(["settings", "extensions", "disable"], {
+  commandTree.register(["extensions", "disable"], {
     description: "Disable an extension by identity (writes settings)",
     handler: (_2, args) => host.handleExtensionsCommand(`disable ${args || ""}`)
   });
@@ -65301,6 +66237,14 @@ function registerBuiltinCommands(host) {
       await host.handleSkillsReload();
     }
   });
+  commandTree.register(["skills", "enable"], {
+    description: "Enable a skill by name (writes settings, reloads immediately)",
+    handler: (_2, args) => host.handleSkillToggleCommand(args || "", true)
+  });
+  commandTree.register(["skills", "disable"], {
+    description: "Disable a skill by name (writes settings, reloads immediately)",
+    handler: (_2, args) => host.handleSkillToggleCommand(args || "", false)
+  });
   for (const skill of host.skills) {
     commandTree.register(["skills", `skill:${skill.name}`], {
       description: skill.description,
@@ -65311,15 +66255,27 @@ function registerBuiltinCommands(host) {
     description: "Spawn subagents in parallel to handle tasks",
     handler: (_2, args) => host.handleSubagentCommand(args || "")
   });
-  commandTree.register(["settings", "debugs", "cache-test"], {
+  commandTree.register(["tools"], {
+    description: "List runtime tools and manage enable/disable toggles",
+    handler: (_2, args) => host.handleToolsCommand(args || "")
+  });
+  commandTree.register(["tools", "enable"], {
+    description: "Enable a tool by name (writes settings; next start)",
+    handler: (_2, args) => host.handleToolsCommand(`enable ${args || ""}`)
+  });
+  commandTree.register(["tools", "disable"], {
+    description: "Disable a tool by name (writes settings; next start)",
+    handler: (_2, args) => host.handleToolsCommand(`disable ${args || ""}`)
+  });
+  commandTree.register(["debugs", "cache-test"], {
     description: "Run provider cache diagnostics with a dedicated 2-request probe",
     handler: () => host.handleCacheTest()
   });
-  commandTree.register(["settings", "debugs", "context"], {
+  commandTree.register(["debugs", "context"], {
     description: "Append a context summary to ~/.pie/logs/pie-cli.log",
     handler: () => host.handleDebugContextCommand()
   });
-  commandTree.register(["settings", "debugs", "package"], {
+  commandTree.register(["debugs", "package"], {
     description: "Append a package summary to ~/.pie/logs/pie-cli.log",
     handler: () => host.handleDebugPackageCommand()
   });
@@ -66238,7 +67194,7 @@ function setupInteractiveEditorSubmitHandler(host) {
     host.ui.requestRender();
     await new Promise((resolve7) => setImmediate(resolve7));
     let finalContent = messageContent;
-    const reminderPrefix = host.executionReminder;
+    const reminderPrefix = host.executionState.getReminder() ?? host.executionReminder;
     const combinedPrefix = [reminderPrefix].filter((value) => Boolean(value)).join("");
     if (combinedPrefix) {
       if (typeof messageContent === "string") {
@@ -67202,17 +68158,17 @@ var MentionHandler = class {
       } catch (err) {
         this.onInsertMention("", pendingMention);
         this.clearPendingStatus(pendingStatusKey);
-        const errorMessage3 = err instanceof Error ? err.message : String(err);
-        if (errorMessage3.includes("PLATFORM_NOT_SUPPORTED")) {
+        const errorMessage4 = err instanceof Error ? err.message : String(err);
+        if (errorMessage4.includes("PLATFORM_NOT_SUPPORTED")) {
           this.onError?.("The current AI model does not support file uploads.");
-        } else if (errorMessage3.includes("ENOENT")) {
+        } else if (errorMessage4.includes("ENOENT")) {
           this.onError?.("File does not exist or cannot be accessed.");
-        } else if (errorMessage3.includes("EACCES") || errorMessage3.includes("PERMISSION")) {
+        } else if (errorMessage4.includes("EACCES") || errorMessage4.includes("PERMISSION")) {
           this.onError?.("Permission denied while accessing the file.");
-        } else if (errorMessage3.includes("network") || errorMessage3.includes("ETIMEDOUT") || errorMessage3.includes("ECONNREFUSED")) {
+        } else if (errorMessage4.includes("network") || errorMessage4.includes("ETIMEDOUT") || errorMessage4.includes("ECONNREFUSED")) {
           this.onError?.("Network error. Check the connection and try again.");
         } else {
-          this.onError?.(`Upload failed: ${errorMessage3}`);
+          this.onError?.(`Upload failed: ${errorMessage4}`);
         }
       } finally {
         this.clearPendingStatus(pendingStatusKey);
@@ -68412,8 +69368,8 @@ function calculateCliContextUsage(params) {
   };
 }
 function createCliAutoCompactDecision(params) {
-  const errorMessage3 = params.message?.role === "assistant" ? params.message.errorMessage : void 0;
-  if (errorMessage3 && params.isContextOverflowError(errorMessage3)) {
+  const errorMessage4 = params.message?.role === "assistant" ? params.message.errorMessage : void 0;
+  if (errorMessage4 && params.isContextOverflowError(errorMessage4)) {
     return { reason: "overflow", willRetry: true };
   }
   if (!params.autoCompactEnabled || params.contextWindow <= 0) {
@@ -68499,9 +69455,9 @@ var INVALID_FILE_REFERENCE_PATTERN = /not the owner of this file|owner of this f
 var INVALID_REQUEST_PATTERN = /bad request|\b400\b|invalid request|invalid schema|schema validation|invalid parameter|unsupported parameter|malformed/i;
 var CLI_RETRY_MAX_RETRIES = 3;
 var CLI_RETRY_BASE_DELAY_MS = 2e3;
-function isCliContextOverflowError(errorMessage3) {
+function isCliContextOverflowError(errorMessage4) {
   return /context length exceeded|context_length_exceeded|maximum context length|maximum context size|too many tokens|input.*too long|prompt.*too long|context window|token limit exceeded|exceeds.{0,20}context/i.test(
-    errorMessage3
+    errorMessage4
   );
 }
 function createClassification(kind, message, overrides) {
@@ -68516,56 +69472,56 @@ function createClassification(kind, message, overrides) {
   };
 }
 function classifyCliFailure(context) {
-  const errorMessage3 = typeof context === "string" ? context : context.errorMessage;
-  if (isCliContextOverflowError(errorMessage3)) {
-    return createClassification("context_overflow", errorMessage3, {
+  const errorMessage4 = typeof context === "string" ? context : context.errorMessage;
+  if (isCliContextOverflowError(errorMessage4)) {
+    return createClassification("context_overflow", errorMessage4, {
       compactable: true,
       terminal: false
     });
   }
-  if (USER_ABORT_PATTERN.test(errorMessage3)) {
-    return createClassification("user_abort", errorMessage3, {
+  if (USER_ABORT_PATTERN.test(errorMessage4)) {
+    return createClassification("user_abort", errorMessage4, {
       userAbort: true,
       terminal: false
     });
   }
-  if (INVALID_FILE_REFERENCE_PATTERN.test(errorMessage3)) {
-    return createClassification("invalid_file_reference", errorMessage3);
+  if (INVALID_FILE_REFERENCE_PATTERN.test(errorMessage4)) {
+    return createClassification("invalid_file_reference", errorMessage4);
   }
-  if (AUTH_CONFIG_PATTERN.test(errorMessage3)) {
-    return createClassification("auth_config", errorMessage3);
+  if (AUTH_CONFIG_PATTERN.test(errorMessage4)) {
+    return createClassification("auth_config", errorMessage4);
   }
-  if (TRANSIENT_NETWORK_ERROR_PATTERN.test(errorMessage3)) {
-    return createClassification("transient_network", errorMessage3, {
+  if (TRANSIENT_NETWORK_ERROR_PATTERN.test(errorMessage4)) {
+    return createClassification("transient_network", errorMessage4, {
       retryable: true,
       terminal: false
     });
   }
-  if (errorMessage3.includes(EMPTY_ASSISTANT_CONTENT_ERROR)) {
-    return createClassification("provider_transient", errorMessage3, {
+  if (errorMessage4.includes(EMPTY_ASSISTANT_CONTENT_ERROR)) {
+    return createClassification("provider_transient", errorMessage4, {
       retryable: true,
       terminal: false
     });
   }
-  if (errorMessage3.includes(OPENAI_COMPAT_PROTOCOL_ERROR_CODE)) {
-    return createClassification("provider_transient", errorMessage3, {
+  if (errorMessage4.includes(OPENAI_COMPAT_PROTOCOL_ERROR_CODE)) {
+    return createClassification("provider_transient", errorMessage4, {
       retryable: true,
       terminal: false
     });
   }
-  if (PROVIDER_TRANSIENT_ERROR_PATTERN.test(errorMessage3)) {
-    return createClassification("provider_transient", errorMessage3, {
+  if (PROVIDER_TRANSIENT_ERROR_PATTERN.test(errorMessage4)) {
+    return createClassification("provider_transient", errorMessage4, {
       retryable: true,
       terminal: false
     });
   }
-  if (INVALID_REQUEST_PATTERN.test(errorMessage3)) {
-    return createClassification("invalid_request", errorMessage3);
+  if (INVALID_REQUEST_PATTERN.test(errorMessage4)) {
+    return createClassification("invalid_request", errorMessage4);
   }
-  return createClassification("unknown", errorMessage3);
+  return createClassification("unknown", errorMessage4);
 }
-function isCliRetryableError(errorMessage3) {
-  return classifyCliFailure(errorMessage3).retryable;
+function isCliRetryableError(errorMessage4) {
+  return classifyCliFailure(errorMessage4).retryable;
 }
 function getCliRetryBaseDelayMs() {
   const override = process.env.PIE_TEST_CLI_RETRY_BASE_DELAY_MS;
@@ -68738,23 +69694,23 @@ function setupAutocomplete(host) {
   };
   host.editor.setAutocompleteProvider(provider);
 }
-function isContextOverflowError(errorMessage3) {
-  return isCliContextOverflowError(errorMessage3);
+function isContextOverflowError(errorMessage4) {
+  return isCliContextOverflowError(errorMessage4);
 }
 function shouldAutoCompact(host, contextTokens, contextWindow) {
   if (!host.options.settingsManager.getAutoCompactEnabled()) return false;
   const reserveTokens = host.options.settingsManager.getAutoCompactReserveTokens();
   return shouldCliAutoCompactTokens({ tokens: contextTokens, contextWindow, reserveTokens });
 }
-function isRetryableError(errorMessage3) {
-  return isCliRetryableError(errorMessage3);
+function isRetryableError(errorMessage4) {
+  return isCliRetryableError(errorMessage4);
 }
-function isInvalidFileReferenceError(errorMessage3) {
+function isInvalidFileReferenceError(errorMessage4) {
   return /not the owner of this file|owner of this file|invalid_authentication_error/i.test(
-    errorMessage3
+    errorMessage4
   );
 }
-function recoverFromInvalidFileReferenceError(host, errorMessage3) {
+function recoverFromInvalidFileReferenceError(host, errorMessage4) {
   if (!host.fileManager || !host.agent) return;
   const messages = host.agent.state.messages.slice();
   const invalidFileIds = /* @__PURE__ */ new Set();
@@ -68772,7 +69728,7 @@ function recoverFromInvalidFileReferenceError(host, errorMessage3) {
   }
   if (invalidFileIds.size === 0) return;
   for (const fileId of invalidFileIds) {
-    host.fileManager.markFileReferenceError(fileId, errorMessage3);
+    host.fileManager.markFileReferenceError(fileId, errorMessage4);
   }
   let changed = false;
   const sanitizedMessages = messages.map((message) => {
@@ -69050,9 +70006,9 @@ function showStatus(host, message) {
   host.lastStatusText = text;
   host.ui.requestRender();
 }
-function showError(host, errorMessage3) {
+function showError(host, errorMessage4) {
   host.chatContainer.addChild(new Spacer(1));
-  host.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage3}`), 1, 0));
+  host.chatContainer.addChild(new Text(theme.fg("error", `Error: ${errorMessage4}`), 1, 0));
   host.ui.requestRender();
 }
 async function executeCommand(host, command) {
@@ -69279,7 +70235,7 @@ function createInteractiveAgentSessionController(host) {
     getAutoContinueMessage: () => host.getTodoAutoContinueMessage(),
     classifyFailure: (context) => classifyCliFailure(context),
     retry: {
-      isRetryableError: (errorMessage3) => !host._isContextOverflowError(errorMessage3) && isCliRetryableError(errorMessage3),
+      isRetryableError: (errorMessage4) => !host._isContextOverflowError(errorMessage4) && isCliRetryableError(errorMessage4),
       maxRetries: CLI_RETRY_MAX_RETRIES,
       baseDelayMs: getCliRetryBaseDelayMs()
     },
@@ -69431,6 +70387,13 @@ function createInteractiveAgentSessionController(host) {
           host.appendWarningSummary(outcome.terminalSummary);
         }
         host.setControllerBusy(false);
+      } else if (event.type === "runtime_guard_advisory") {
+        host.noteRuntimeGuardAdvisory(event);
+        host.sessionTrace.noteRuntimeEvent("runtime_guard_advisory", {
+          toolName: event.toolName,
+          repeatCount: event.repeatCount,
+          reason: event.reason
+        });
       } else if (event.type === "runtime_guard_triggered") {
         host.sessionTrace.noteStalled("runtime_guard_triggered", {
           toolName: event.toolName,
@@ -69631,6 +70594,43 @@ function createRuntimeModeTransformContext(options) {
   };
 }
 
+// src/runtime/guard-advisory-context.ts
+var GUARD_ADVISORY_MARKER = "<runtime-guard-advisory>";
+var GUARD_ADVISORY_END_MARKER = "</runtime-guard-advisory>";
+function isMarkerOnlyUserMessage(message) {
+  if (message.role !== "user") return false;
+  const content = message.content;
+  const text = typeof content === "string" ? content : Array.isArray(content) && content.length === 1 && content[0]?.type === "text" ? content[0].text : "";
+  return text.trim().startsWith(GUARD_ADVISORY_MARKER) && text.trim().endsWith(GUARD_ADVISORY_END_MARKER);
+}
+function stripGuardAdvisories(messages) {
+  return messages.filter((message) => !isMarkerOnlyUserMessage(message));
+}
+function findLatestUserIndex2(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index].role === "user") return index;
+  }
+  return -1;
+}
+function injectGuardAdvisory(messages, guidance) {
+  const advisoryMessage = {
+    role: "user",
+    content: `${GUARD_ADVISORY_MARKER}
+${guidance}
+${GUARD_ADVISORY_END_MARKER}`,
+    timestamp: Date.now()
+  };
+  const latestUserIndex = findLatestUserIndex2(messages);
+  if (latestUserIndex < 0) {
+    return [...messages, advisoryMessage];
+  }
+  return [
+    ...messages.slice(0, latestUserIndex),
+    advisoryMessage,
+    ...messages.slice(latestUserIndex)
+  ];
+}
+
 // src/runtime/tool-policy.ts
 function selectToolsForRuntimeMode(tools, mode) {
   return selectToolsForRuntimePolicy(tools, mode);
@@ -70321,7 +71321,7 @@ async function loadInteractiveExtensions(host) {
       console.error(`[Extension] Failed to load ${path33}: ${error}`);
     }
   }
-  const extensionTools = convertExtensionTools(extensions);
+  const extensionTools = filterEnabledTools(convertExtensionTools(extensions), host.options.settingsManager);
   const activeTools = [...host.agent.state.tools, ...extensionTools];
   host.agent.state.tools = wrapToolsWithExtensions(activeTools, host.extensionRunner);
   const availableTools = [
@@ -70390,12 +71390,13 @@ var InteractiveMode = class {
   isProcessing = false;
   _turnIndex = 0;
   _semanticTurnIndex = 0;
-  thinkingLevel = "off";
+  thinkingLevel = DEFAULT_THINKING_LEVEL;
   toolOutputExpanded = false;
   planModeEnabled = false;
   pendingPlanModeTransition = null;
   pendingYoloModeTransition = null;
   executionReminder = null;
+  pendingRuntimeGuardAdvisory = null;
   fileManager;
   mentionHandler;
   mentionPickerComponent;
@@ -70705,12 +71706,9 @@ var InteractiveMode = class {
     });
   }
   async init() {
-    const savedLevel = this.options.settingsManager.getDefaultThinkingLevel();
-    if (savedLevel) {
-      this.thinkingLevel = savedLevel;
-    }
-    const { Agent } = await import("./chunks/src-HYZFAW4V.js");
     const activeSession = this.sessionManager.getActiveSession();
+    this.thinkingLevel = resolveInitialThinkingLevel({ session: activeSession, settingsManager: this.options.settingsManager });
+    const { Agent } = await import("./chunks/src-HYZFAW4V.js");
     this.agent = new Agent({
       initialState: {
         systemPrompt: this.buildSystemPrompt(),
@@ -70721,20 +71719,27 @@ var InteractiveMode = class {
       apiKey: this.options.apiKey,
       sessionId: activeSession?.id,
       streamFn: this.options.streamFn,
-      transformContext: createRuntimeModeTransformContext({
-        getState: () => this.getRuntimeModeState(),
-        consumeTransition: () => this.consumeRuntimeModeTransition(),
-        onInjected: (state) => this.sessionTrace.noteRuntimeEvent("runtime_context_injected", {
-          yoloMode: state.yoloMode,
-          planMode: state.planMode,
-          filesystemScope: state.filesystemScope,
-          pendingTransition: state.pendingTransition,
-          currentDate: state.currentDate,
-          timeZone: state.timeZone,
-          activeToolCount: state.activeToolNames.length
-        }),
-        onStripped: (count) => this.sessionTrace.noteRuntimeEvent("stale_runtime_context_stripped", { count })
-      })
+      transformContext: async (messages) => {
+        const runtimeModeTransform = createRuntimeModeTransformContext({
+          getState: () => this.getRuntimeModeState(),
+          consumeTransition: () => this.consumeRuntimeModeTransition(),
+          onInjected: (state) => this.sessionTrace.noteRuntimeEvent("runtime_context_injected", {
+            yoloMode: state.yoloMode,
+            planMode: state.planMode,
+            filesystemScope: state.filesystemScope,
+            pendingTransition: state.pendingTransition,
+            currentDate: state.currentDate,
+            timeZone: state.timeZone,
+            activeToolCount: state.activeToolNames.length
+          }),
+          onStripped: (count) => this.sessionTrace.noteRuntimeEvent("stale_runtime_context_stripped", { count })
+        });
+        let transformed = await runtimeModeTransform(messages);
+        const advisory = this.pendingRuntimeGuardAdvisory;
+        this.pendingRuntimeGuardAdvisory = null;
+        transformed = advisory ? injectGuardAdvisory(transformed, advisory) : stripGuardAdvisories(transformed);
+        return transformed;
+      }
     });
     this.agentSessionController = createInteractiveAgentSessionController(this.controllerSetupHost);
     this.updateTerminalTitle();
@@ -70837,6 +71842,10 @@ var InteractiveMode = class {
   calculateContextUsage() {
     return calculateContextUsage(this.contextUiHost);
   }
+  noteRuntimeGuardAdvisory(event) {
+    this.pendingRuntimeGuardAdvisory = event.guidance;
+    this.showStatus(`Runtime guard: ${event.toolName} failed ${event.repeatCount}x identically; advisory queued for next request.`);
+  }
   persistExecutionState() {
     const activeSession = this.sessionManager.getActiveSession();
     if (!activeSession) return;
@@ -70865,20 +71874,20 @@ var InteractiveMode = class {
   setupAgentSubscription() {
     bindInteractiveRuntimeEvents(this.runtimeEventHost);
   }
-  _isContextOverflowError(errorMessage3) {
-    return isContextOverflowError(errorMessage3);
+  _isContextOverflowError(errorMessage4) {
+    return isContextOverflowError(errorMessage4);
   }
   _shouldAutoCompact(contextTokens, contextWindow) {
     return shouldAutoCompact(this.contextUiHost, contextTokens, contextWindow);
   }
-  _isRetryableError(errorMessage3) {
-    return isRetryableError(errorMessage3);
+  _isRetryableError(errorMessage4) {
+    return isRetryableError(errorMessage4);
   }
-  _isInvalidFileReferenceError(errorMessage3) {
-    return isInvalidFileReferenceError(errorMessage3);
+  _isInvalidFileReferenceError(errorMessage4) {
+    return isInvalidFileReferenceError(errorMessage4);
   }
-  _recoverFromInvalidFileReferenceError(errorMessage3) {
-    return recoverFromInvalidFileReferenceError(this.contextUiHost, errorMessage3);
+  _recoverFromInvalidFileReferenceError(errorMessage4) {
+    return recoverFromInvalidFileReferenceError(this.contextUiHost, errorMessage4);
   }
   async handleCompactCommand() {
     return handleCompactCommand(this.compactCommandHost);
@@ -70969,7 +71978,7 @@ var InteractiveMode = class {
     return handleResumeCommand(this);
   }
   async loadSession(sessionId) {
-    return loadSession(this, sessionId);
+    return loadSession2(this, sessionId);
   }
   updateTerminalTitle() {
     return updateTerminalTitle(this);
@@ -71031,6 +72040,12 @@ var InteractiveMode = class {
   async handleSkillsReload() {
     return handleSkillsReload(this);
   }
+  async handleSkillToggleCommand(args, enabled) {
+    return handleSkillToggleCommand(this, args, enabled);
+  }
+  handleToolsCommand(args) {
+    return handleToolsCommand(this, args);
+  }
   isInteractiveCommand(commandPath) {
     const interactiveCommands = [
       "/skills/create",
@@ -71049,8 +72064,8 @@ var InteractiveMode = class {
   showStatus(message) {
     return showStatus(this.uiHelperHost, message);
   }
-  showError(errorMessage3) {
-    return showError(this.uiHelperHost, errorMessage3);
+  showError(errorMessage4) {
+    return showError(this.uiHelperHost, errorMessage4);
   }
   async handleDirectBash(command) {
     return handleDirectBash(this.directBashHost, command);
@@ -71224,8 +72239,8 @@ async function composeCliRuntime(params) {
   } else {
     await sessionManager.createSession();
   }
-  syncSessionModelMetadata(sessionManager, model, settingsManager.getDefaultThinkingLevel() || "off");
   const activeSession = sessionManager.getActiveSession();
+  syncSessionModelMetadata(sessionManager, model, resolveInitialThinkingLevel({ session: activeSession, settingsManager }));
   if (activeSession && activeSession.metadata.cwd !== cwd) {
     activeSession.metadata.cwd = cwd;
     await sessionManager.save();
@@ -71242,7 +72257,7 @@ async function composeCliRuntime(params) {
     keyPrefix: apiKey ? maskApiKey2(apiKey) : "none"
   });
   const projectSkillsDir = path30.join(cwd, ".pie", "skills");
-  const { skills, diagnostics } = loadSkills({
+  const { skills: discoveredSkills, diagnostics } = loadSkills({
     dirs: buildSkillDirs({
       builtinDir: paths.builtinSkillsDir,
       userDir: paths.skillsDir,
@@ -71250,6 +72265,7 @@ async function composeCliRuntime(params) {
       cwd
     })
   });
+  const skills = discoveredSkills.filter((skill) => settingsManager.isSkillEnabled(skill.name));
   let interactiveOptions;
   const getCurrentModel = () => interactiveOptions?.model ?? model;
   const cliHostCapabilities = createCliHostCapabilities(cwd, {
@@ -71273,22 +72289,23 @@ async function composeCliRuntime(params) {
     ...createCliFileSystemTools(cwd, fileSystemToolOptions),
     ...cliHostCapabilities.tools
   ];
+  const enabledRawTools = filterEnabledTools(rawTools, settingsManager);
   recordCliCompositionStep(compositionTrace, {
     id: "host_shared_capabilities",
     inputSummary: `cwd=${cwd}`,
-    outputSummary: summarizeToolNames(rawTools),
-    toolCount: rawTools.length
+    outputSummary: summarizeToolNames(enabledRawTools),
+    toolCount: enabledRawTools.length
   });
-  const allTools = createPolicyEnforcedTools(rawTools, {
+  const allTools = createPolicyEnforcedTools(enabledRawTools, {
     getContext: () => ({ mode: "normal", confirmationPolicy: "allow" })
   });
   const tools = [...allTools];
   recordCliCompositionStep(compositionTrace, {
     id: "policy_filtering",
-    inputSummary: `tools=${rawTools.length}`,
+    inputSummary: `tools=${enabledRawTools.length}`,
     outputSummary: summarizeToolNames(tools),
     toolCount: tools.length,
-    policyDecisions: rawTools.length === allTools.length ? ["allow:default"] : [`filtered:${rawTools.length - allTools.length}`]
+    policyDecisions: enabledRawTools.length === allTools.length ? ["allow:default"] : [`filtered:${enabledRawTools.length - allTools.length}`]
   });
   for (const diag of diagnostics.filter((d) => d.type === "collision")) {
     console.log(`[CLI] ${diag.message}`);
@@ -71473,7 +72490,7 @@ async function loadPrintModeExtensions(params) {
   );
   runner.setUIContext(uiContext);
   await restoreExtensionProviderCredentials(params.modelRegistry);
-  const extensionTools = convertExtensionTools(extensions);
+  const extensionTools = filterEnabledTools(convertExtensionTools(extensions), params.settingsManager);
   availableTools = [...availableTools, ...extensionTools];
   return {
     extensions,
@@ -71533,12 +72550,13 @@ async function runPrintMode(params) {
     knowledgeSection: runtime.knowledgeSection,
     tools: printModeTools.map((tool) => ({ name: tool.name, description: tool.description }))
   });
+  const printThinkingLevel = resolveInitialThinkingLevel({ session: runtime.sessionManager.getActiveSession(), settingsManager: runtime.settingsManager });
   agent = new AgentClass({
     initialState: {
       systemPrompt: baseSystemPrompt,
       model: runtime.model,
       tools: printModeTools,
-      thinkingLevel: "off"
+      thinkingLevel: printThinkingLevel
     },
     apiKey: runtime.apiKey,
     streamFn: params.streamFn
@@ -71673,21 +72691,21 @@ async function runPrintMode(params) {
       console.log(assistantText);
     }
   } catch (err) {
-    const errorMessage3 = err instanceof Error ? err.message : String(err);
-    sessionTrace.noteStalled(errorMessage3, { mode: "print" });
+    const errorMessage4 = err instanceof Error ? err.message : String(err);
+    sessionTrace.noteStalled(errorMessage4, { mode: "print" });
     process.exitCode = 1;
     if (params.jsonOutput) {
       console.log(
         JSON.stringify({
           ok: false,
-          error: errorMessage3,
+          error: errorMessage4,
           sessionId: runtime.sessionManager.getActiveSession()?.id,
           provider: runtime.provider,
           modelId: runtime.modelId
         })
       );
     }
-    console.error("Error:", errorMessage3);
+    console.error("Error:", errorMessage4);
   }
   if (!params.rawOutput && !params.jsonOutput) {
     console.log("");
@@ -71704,6 +72722,9 @@ var MAX_EVENT_OBJECT_KEYS = 50;
 var MAX_EVENT_ARRAY_ITEMS = 50;
 var MAX_EVENT_VALUE_DEPTH = 4;
 var MAX_EVENT_STRING_LENGTH = 4e3;
+var COMPACT_EVENT_STRING_LENGTH = 800;
+var FULL_DETAIL = "full";
+var COMPACT_DETAIL = "compact";
 function createNoOpExtensionUIContext2() {
   return {
     notify: () => {
@@ -71719,10 +72740,10 @@ function writeEvent(event) {
   process.stdout.write(`${JSON.stringify(event)}
 `);
 }
-function toJsonValue(value, depth = 0) {
+function toJsonValue(value, depth = 0, cap = MAX_EVENT_STRING_LENGTH) {
   if (value === null) return null;
   if (typeof value === "string") {
-    return value.length > MAX_EVENT_STRING_LENGTH ? `${value.slice(0, MAX_EVENT_STRING_LENGTH)}...` : value;
+    return value.length > cap ? value.slice(0, cap) : value;
   }
   if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
   if (typeof value === "boolean") return value;
@@ -71730,17 +72751,33 @@ function toJsonValue(value, depth = 0) {
   if (typeof value !== "object") return void 0;
   if (depth >= MAX_EVENT_VALUE_DEPTH) return "[truncated]";
   if (Array.isArray(value)) {
-    return value.slice(0, MAX_EVENT_ARRAY_ITEMS).map((item) => toJsonValue(item, depth + 1) ?? null);
+    return value.slice(0, MAX_EVENT_ARRAY_ITEMS).map((item) => toJsonValue(item, depth + 1, cap) ?? null);
   }
   const result = {};
   for (const [key, item] of Object.entries(value).slice(0, MAX_EVENT_OBJECT_KEYS)) {
-    result[key] = toJsonValue(item, depth + 1);
+    result[key] = toJsonValue(item, depth + 1, cap);
   }
   return result;
 }
 function isRecord4(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
+function truncateForEvent(text, cap) {
+  if (text.length <= cap) {
+    return { value: text, truncated: false, fullLength: text.length };
+  }
+  return { value: text.slice(0, cap), truncated: true, fullLength: text.length };
+}
+function hasOversizedValue(value, cap, depth = 0) {
+  if (typeof value === "string") return value.length > cap;
+  if (!value || typeof value !== "object") return false;
+  if (depth >= MAX_EVENT_VALUE_DEPTH) return true;
+  if (Array.isArray(value)) {
+    return value.length > MAX_EVENT_ARRAY_ITEMS || value.some((item) => hasOversizedValue(item, cap, depth + 1));
+  }
+  const entries = Object.entries(value);
+  return entries.length > MAX_EVENT_OBJECT_KEYS || entries.some(([, item]) => hasOversizedValue(item, cap, depth + 1));
+}
 function parseInput(line) {
   let parsed;
   try {
@@ -71765,8 +72802,7 @@ function parseInput(line) {
       type: "session.rewind",
       sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : void 0,
       requestId: typeof parsed.requestId === "string" ? parsed.requestId : void 0,
-      entryId: typeof parsed.entryId === "string" ? parsed.entryId : void 0,
-      checkpointId: typeof parsed.checkpointId === "string" ? parsed.checkpointId : void 0
+      entryId: typeof parsed.entryId === "string" ? parsed.entryId : void 0
     };
   }
   if (parsed.type === "session.fork") {
@@ -71780,6 +72816,14 @@ function parseInput(line) {
       cwd: typeof parsed.cwd === "string" ? parsed.cwd : void 0
     };
   }
+  if (parsed.type === "sidechat.request" && typeof parsed.requestId === "string" && typeof parsed.prompt === "string") {
+    return {
+      type: "sidechat.request",
+      sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : void 0,
+      requestId: parsed.requestId,
+      prompt: parsed.prompt
+    };
+  }
   if ((parsed.type === "turn.request" || parsed.type === "turn.input") && typeof parsed.turnId === "string" && typeof parsed.prompt === "string") {
     const streamingBehavior = parsed.streamingBehavior;
     if (streamingBehavior !== void 0 && streamingBehavior !== "steer" && streamingBehavior !== "followUp") {
@@ -71813,6 +72857,12 @@ function assistantTextFromMessage(message) {
   }
   return text;
 }
+function assistantUsageFromAgent(agent) {
+  const messages = agent?.state.messages ?? [];
+  const lastMessage = messages[messages.length - 1];
+  if (lastMessage?.role !== "assistant") return void 0;
+  return toJsonValue(lastMessage.usage);
+}
 function assistantErrorFromAgent(agent) {
   const messages = agent?.state.messages ?? [];
   const lastMessage = messages[messages.length - 1];
@@ -71921,7 +72971,7 @@ async function loadJsonModeExtensions(params) {
   );
   runner.setUIContext(uiContext);
   await restoreExtensionProviderCredentials(params.runtime.modelRegistry);
-  const extensionTools = convertExtensionTools(extensions);
+  const extensionTools = filterEnabledTools(convertExtensionTools(extensions), params.runtime.settingsManager);
   availableTools = [...availableTools, ...extensionTools];
   return {
     runner,
@@ -71930,6 +72980,8 @@ async function loadJsonModeExtensions(params) {
   };
 }
 async function runJsonEventsMode(params) {
+  const eventDetail = params.eventDetail === FULL_DETAIL ? FULL_DETAIL : COMPACT_DETAIL;
+  const eventStringCap = eventDetail === FULL_DETAIL ? MAX_EVENT_STRING_LENGTH : COMPACT_EVENT_STRING_LENGTH;
   const sessionId = params.explicitSessionId || params.runtime?.sessionManager.getActiveSession()?.id || `pie-json-${Date.now()}`;
   let activeTurn = null;
   let runtime = params.runtime;
@@ -71940,13 +72992,28 @@ async function runJsonEventsMode(params) {
   let trace;
   let lastRetryEvent;
   let mockActiveEntryId;
-  let thinkingLevel = "off";
+  let thinkingLevel = DEFAULT_THINKING_LEVEL;
+  let thinkingLevelInitialized = false;
   let defaultRuntime;
   let defaultModelState;
   const completedSessionControlRequests = /* @__PURE__ */ new Map();
+  const completedSidechatRequests = /* @__PURE__ */ new Map();
+  const ensureRuntimeInFlight = /* @__PURE__ */ new Map();
+  let activeSidechat = null;
+  let activeSidechatPromise = null;
+  let sidechatChainStopped = false;
   const noProgressTimeoutMs = Number(process.env.PIE_JSON_EVENTS_NO_PROGRESS_MS || 6e5);
   const mockResponseDelayMs = Number(process.env.PIE_TEST_MOCK_RESPONSE_DELAY_MS || 0);
+  const prewarmTimeoutMs = Number(process.env.PIE_JSON_EVENTS_PREWARM_TIMEOUT_MS || 1e4);
+  const sidechatTimeoutMs = Number(process.env.PIE_JSON_EVENTS_SIDECHAT_TIMEOUT_MS || 3e5);
+  await prewarmRuntime();
   writeEvent({ type: "agent.ready", sessionId });
+  function trackSidechatPromise(promise) {
+    activeSidechatPromise = promise;
+    void promise.finally(() => {
+      if (activeSidechatPromise === promise) activeSidechatPromise = null;
+    });
+  }
   function sessionMismatchError(requestedSessionId) {
     return `session mismatch: JSON events process is bound to ${sessionId}, received ${requestedSessionId}`;
   }
@@ -72118,15 +73185,10 @@ async function runJsonEventsMode(params) {
   }
   function resolveRewindEntryId(message) {
     const entryId = message.entryId?.trim();
-    const checkpointId = message.checkpointId?.trim();
-    if (entryId && checkpointId && entryId !== checkpointId) {
-      throw invalidSessionControl("entryId and checkpointId must match when both are provided");
+    if (!entryId) {
+      throw invalidSessionControl("entryId is required");
     }
-    const resolved = entryId || checkpointId;
-    if (!resolved) {
-      throw invalidSessionControl("entryId or checkpointId is required");
-    }
-    return resolved;
+    return entryId;
   }
   function writeSessionControlFailure(message, operation, error) {
     const detail = error instanceof SessionControlError ? error : new SessionControlError("session_io_error", error instanceof Error ? error.message : String(error));
@@ -72178,14 +73240,12 @@ async function runJsonEventsMode(params) {
         entryId
       });
       await syncRuntimeAfterRewind(controlSessionId);
-      mockActiveEntryId = result.headEntryId;
+      mockActiveEntryId = result.activeEntryId;
       const event = {
         type: "session.rewound",
         sessionId: controlSessionId,
         requestId,
         entryId: result.entryId,
-        checkpointId: result.checkpointId,
-        headEntryId: result.headEntryId,
         activeEntryId: result.activeEntryId
       };
       completedSessionControlRequests.set(requestId, event);
@@ -72222,11 +73282,8 @@ async function runJsonEventsMode(params) {
         requestId,
         sourceSessionId: result.sourceSessionId,
         sourceEntryId: result.sourceEntryId,
-        sourceCheckpointId: result.sourceCheckpointId,
         targetSessionId: result.targetSessionId,
-        targetHeadEntryId: result.targetHeadEntryId,
-        targetActiveEntryId: result.targetActiveEntryId,
-        headEntryId: result.headEntryId
+        targetActiveEntryId: result.targetActiveEntryId
       };
       completedSessionControlRequests.set(requestId, event);
       writeEvent(event);
@@ -72234,21 +73291,150 @@ async function runJsonEventsMode(params) {
       writeSessionControlFailure(message, "fork", error);
     }
   }
+  function writeSidechatFailure(message, error, code) {
+    writeEvent({
+      type: "sidechat.failed",
+      sessionId,
+      requestId: message.requestId.trim(),
+      error,
+      code
+    });
+  }
+  async function handleSidechat(message) {
+    if (isSessionMismatch(message)) {
+      writeSidechatFailure(message, sessionMismatchError(message.sessionId), "session_mismatch");
+      return;
+    }
+    const requestId = message.requestId.trim();
+    if (!requestId) {
+      writeSidechatFailure(message, "requestId is required", "invalid_request");
+      return;
+    }
+    const cached = completedSidechatRequests.get(requestId);
+    if (cached) {
+      writeEvent(cached);
+      return;
+    }
+    if (activeTurn && !activeTurn.finalized) {
+      writeSidechatFailure(message, "Cannot run sidechat while a turn is active", "session_busy");
+      return;
+    }
+    const startedAt = Date.now();
+    if (params.mockResponse !== void 0) {
+      writeEvent({ type: "sidechat.started", sessionId, requestId });
+      const event = {
+        type: "sidechat.completed",
+        sessionId,
+        requestId,
+        text: params.mockResponse,
+        durationMs: Date.now() - startedAt
+      };
+      completedSidechatRequests.set(requestId, event);
+      writeEvent(event);
+      return;
+    }
+    writeEvent({ type: "sidechat.started", sessionId, requestId });
+    const sidechatController = new AbortController();
+    let abortKind;
+    activeSidechat = {
+      abort: () => {
+        if (!abortKind) abortKind = "interrupted";
+        sidechatController.abort();
+      }
+    };
+    try {
+      await ensureRuntime();
+      if (!agent || !runtime) {
+        throw new Error("JSON events runtime was not initialized");
+      }
+      if (runtime.initialModel.unconfigured) {
+        writeSidechatFailure(message, runtime.initialModel.warning || "No models are configured.");
+        return;
+      }
+      if (sidechatController.signal.aborted) {
+        writeSidechatFailure(message, "sidechat aborted before dispatch", "sidechat_interrupted");
+        return;
+      }
+      const parent = agent;
+      const { Agent: AgentClass } = await import("./chunks/src-HYZFAW4V.js");
+      const sideAgent = new AgentClass({
+        initialState: {
+          systemPrompt: parent.state.systemPrompt,
+          model: parent.state.model,
+          thinkingLevel: parent.state.thinkingLevel,
+          tools: [],
+          messages: structuredClone(parent.state.messages)
+        },
+        apiKey: runtime.apiKey,
+        streamFn: params.streamFn
+      });
+      sidechatController.signal.addEventListener("abort", () => sideAgent.abort(), { once: true });
+      const timer = setTimeout(() => {
+        if (!abortKind) abortKind = "timeout";
+        sidechatController.abort();
+      }, sidechatTimeoutMs);
+      timer.unref?.();
+      try {
+        await sideAgent.prompt(message.prompt);
+      } finally {
+        clearTimeout(timer);
+      }
+      if (abortKind) {
+        const code = abortKind === "timeout" ? "sidechat_timeout" : "sidechat_interrupted";
+        writeSidechatFailure(message, sideAgent.state.error || "sidechat aborted", code);
+        return;
+      }
+      const failure = sideAgent.state.error;
+      if (failure) {
+        writeSidechatFailure(message, failure);
+        return;
+      }
+      const sidechatText = assistantTextFromAgent(sideAgent);
+      const capped = sidechatText === void 0 ? void 0 : truncateForEvent(sidechatText, eventStringCap);
+      const event = {
+        type: "sidechat.completed",
+        sessionId,
+        requestId,
+        text: capped?.value,
+        ...capped?.truncated ? { truncated: true, fullLength: capped.fullLength } : {},
+        usage: assistantUsageFromAgent(sideAgent),
+        durationMs: Date.now() - startedAt
+      };
+      completedSidechatRequests.set(requestId, event);
+      writeEvent(event);
+    } catch (error) {
+      const detail = errorToFailureDetail(error);
+      writeSidechatFailure(
+        message,
+        typeof detail === "string" ? detail : detail.message,
+        typeof detail === "string" ? void 0 : detail.code
+      );
+    } finally {
+      activeSidechat = null;
+    }
+  }
   function finalize(kind, detail) {
     const turn = activeTurn;
     if (!turn || turn.finalized) return;
     turn.finalized = true;
-    const headEntryId = activeHeadEntryId();
+    const activeEntryId = activeHeadEntryId();
     const base = {
       sessionId: turn.sessionId,
       turnId: turn.turnId,
-      headEntryId,
-      activeEntryId: headEntryId
+      activeEntryId
     };
     switch (kind) {
-      case "completed":
-        writeEvent({ type: "turn.completed", ...base, summary: (typeof detail === "string" ? detail : turn.summary).trim() });
+      case "completed": {
+        const summaryText = (typeof detail === "string" ? detail : turn.summary).trim();
+        const capped = truncateForEvent(summaryText, eventStringCap);
+        writeEvent({
+          type: "turn.completed",
+          ...base,
+          summary: capped.value,
+          ...capped.truncated ? { truncated: true, fullLength: capped.fullLength } : {}
+        });
         break;
+      }
       case "failed":
         writeEvent({ type: "turn.failed", ...base, ...failureDetail(detail) });
         break;
@@ -72261,13 +73447,12 @@ async function runJsonEventsMode(params) {
     }
   }
   function emitSettled(turn) {
-    const headEntryId = activeHeadEntryId();
+    const activeEntryId = activeHeadEntryId();
     writeEvent({
       type: "turn.settled",
       sessionId: turn.sessionId,
       turnId: turn.turnId,
-      headEntryId,
-      activeEntryId: headEntryId
+      activeEntryId
     });
   }
   function rememberTerminal(kind, detail, options) {
@@ -72290,14 +73475,20 @@ async function runJsonEventsMode(params) {
         break;
       case "tool_started":
         touch();
-        writeEvent({
-          type: "tool.started",
-          sessionId: activeTurn.sessionId,
-          turnId: activeTurn.turnId,
-          toolCallId: event.toolCallId,
-          name: event.toolName,
-          data: toJsonValue({ args: event.args })
-        });
+        {
+          const argsOversized = eventDetail === COMPACT_DETAIL && hasOversizedValue(event.args, eventStringCap);
+          writeEvent({
+            type: "tool.started",
+            sessionId: activeTurn.sessionId,
+            turnId: activeTurn.turnId,
+            toolCallId: event.toolCallId,
+            name: event.toolName,
+            data: toJsonValue({
+              args: event.args,
+              ...argsOversized ? { truncated: true } : {}
+            }, 0, eventStringCap)
+          });
+        }
         break;
       case "tool_progressed":
         touch();
@@ -72311,18 +73502,23 @@ async function runJsonEventsMode(params) {
         break;
       case "tool_finished":
         touch();
-        writeEvent({
-          type: "tool.completed",
-          sessionId: activeTurn.sessionId,
-          turnId: activeTurn.turnId,
-          toolCallId: event.toolCallId,
-          name: event.toolName,
-          status: event.isError ? "error" : "ok",
-          data: toJsonValue({
-            resultText: extractJsonEventsToolProgressText(event.result),
-            isError: event.isError
-          })
-        });
+        {
+          const resultText = extractJsonEventsToolProgressText(event.result);
+          const capped = resultText === void 0 || resultText === null ? void 0 : truncateForEvent(resultText, eventStringCap);
+          writeEvent({
+            type: "tool.completed",
+            sessionId: activeTurn.sessionId,
+            turnId: activeTurn.turnId,
+            toolCallId: event.toolCallId,
+            name: event.toolName,
+            status: event.isError ? "error" : "ok",
+            data: toJsonValue({
+              resultText: capped?.value,
+              isError: event.isError,
+              ...capped?.truncated ? { truncated: true, fullLength: capped.fullLength } : {}
+            }, 0, eventStringCap)
+          });
+        }
         break;
     }
   }
@@ -72448,9 +73644,30 @@ async function runJsonEventsMode(params) {
     trace = void 0;
     cleanupBashOutputArtifacts();
   }
+  async function prewarmRuntime() {
+    if (params.mockResponse !== void 0) return;
+    if (!params.createRuntime && !params.runtime) return;
+    try {
+      await new Promise((resolve7, reject) => {
+        const timer = setTimeout(() => reject(new Error("prewarm timeout")), prewarmTimeoutMs);
+        timer.unref?.();
+        void ensureRuntime().then(resolve7, reject).finally(() => clearTimeout(timer));
+      });
+    } catch {
+    }
+  }
   async function ensureRuntime(requestedCwd) {
     if (params.mockResponse !== void 0) return;
     const effectiveCwd = requestedCwd ?? process.cwd();
+    const inFlight = ensureRuntimeInFlight.get(effectiveCwd);
+    if (inFlight) return inFlight;
+    const composed = composeRuntime(effectiveCwd);
+    ensureRuntimeInFlight.set(effectiveCwd, composed);
+    void composed.finally(() => ensureRuntimeInFlight.delete(effectiveCwd)).catch(() => {
+    });
+    return composed;
+  }
+  async function composeRuntime(effectiveCwd) {
     if (params.createRuntime && (!runtime || runtime.cwd !== effectiveCwd)) {
       await disposeRuntime();
       runtime = await params.createRuntime({ cwd: effectiveCwd, sessionId });
@@ -72545,6 +73762,11 @@ async function runJsonEventsMode(params) {
     agent.setTools(wrapToolsWithExtensions(agent.state.tools, jsonModeExtensions.runner));
     controller.updateRuntimeContext({ tools: agent.state.tools });
     disposeSemanticSubscription = agent.subscribeSemantic(handleSemanticEvent);
+    if (!thinkingLevelInitialized) {
+      thinkingLevelInitialized = true;
+      thinkingLevel = resolveInitialThinkingLevel({ session: runtime.sessionManager.getActiveSession(), settingsManager: runtime.settingsManager });
+      agent.setThinkingLevel(thinkingLevel);
+    }
   }
   function metadataSelection(metadata, key) {
     if (!metadata || !(key in metadata)) return void 0;
@@ -72606,6 +73828,7 @@ async function runJsonEventsMode(params) {
       const nextLevel = requestedThinkingLevel === null ? "off" : requestedThinkingLevel;
       if (!isThinkingLevel(nextLevel)) throw new Error(`Unsupported thinkingLevel: ${nextLevel}`);
       thinkingLevel = nextLevel;
+      thinkingLevelInitialized = true;
       applyThinkingLevel({
         level: thinkingLevel,
         agent,
@@ -72865,6 +74088,8 @@ async function runJsonEventsMode(params) {
     }
     if (message.type === "shutdown") {
       shutdownActiveTurn(message.reason);
+      sidechatChainStopped = true;
+      activeSidechat?.abort();
       break;
     }
     if (message.type === "turn.interrupt") {
@@ -72879,6 +74104,24 @@ async function runJsonEventsMode(params) {
       await handleSessionFork(message);
       continue;
     }
+    if (message.type === "sidechat.request") {
+      const prior = activeSidechatPromise ?? Promise.resolve();
+      trackSidechatPromise(prior.then(async () => {
+        if (sidechatChainStopped) {
+          const cached = completedSidechatRequests.get(message.requestId.trim());
+          if (cached) {
+            writeEvent(cached);
+          } else {
+            writeSidechatFailure(message, "sidechat discarded on shutdown", "sidechat_interrupted");
+          }
+          return;
+        }
+        await handleSidechat(message).catch((error) => {
+          writeSidechatFailure(message, error instanceof Error ? error.message : String(error));
+        });
+      }));
+      continue;
+    }
     const shouldTrackTurn = !activeTurn || activeTurn.finalized;
     const turnPromise = runTurn(message).catch((error) => {
       writeEvent({
@@ -72897,6 +74140,7 @@ async function runJsonEventsMode(params) {
     }
   }
   await activeTurnPromise;
+  await activeSidechatPromise;
   await disposeRuntime();
 }
 
@@ -72953,6 +74197,7 @@ Commands:
   sessions         List, read, rename, rewind, and fork Pie sessions
   extensions       List and enable/disable extensions (list/enable/disable)
   permissions      Explain Pie tool and shell safety defaults
+  capabilities     Report command surface and flags for agents (add --json)
   help             Show this help message
 
 Interactive Mode Key Bindings:
@@ -73001,86 +74246,13 @@ setupGlobalErrorHandlers(logError);
 migrateConfigFromAgentDir();
 var STABLE_CLI_COMMANDS = {
   chat: "chat",
+  capabilities: "capabilities",
   doctor: "doctor",
   models: "models",
   sessions: "sessions",
   extensions: "extensions",
   permissions: "permissions"
 };
-async function runDoctorCommand(args) {
-  const json = args.includes("--json");
-  const report = await runDoctor();
-  if (json) {
-    console.log(JSON.stringify(report, null, 2));
-  } else {
-    console.log(formatDoctorReport(report));
-  }
-  if (!report.ok) {
-    process.exitCode = 1;
-  }
-}
-async function runModelsCommand(args) {
-  const subcommand = args[0] || "help";
-  const parsed = parseModelsCommandArgs(args.slice(1));
-  if (subcommand === "init") {
-    const result = initModelsConfig(parsed);
-    if (parsed.stdout) {
-      process.stdout.write(result.content);
-    } else {
-      console.log(`Wrote models.json template: ${result.path}`);
-    }
-    return;
-  }
-  if (subcommand === "validate") {
-    const result = validateModelsConfig({ path: parsed.path });
-    if (parsed.json) {
-      const probe = result.ok && parsed.probe ? await probeModelsConfig({ path: parsed.path, probe: parsed.probe }) : void 0;
-      console.log(JSON.stringify({ ...result, ...probe ? { probe } : {} }, null, 2));
-      if (!result.ok || probe?.status === "failed") process.exitCode = 1;
-      return;
-    }
-    if (!result.ok) {
-      console.error(result.message);
-      process.exitCode = 1;
-      return;
-    }
-    console.log(result.message);
-    if (result.profiles.length > 0) {
-      console.log(`Profiles: ${result.profiles.join(", ")}`);
-      console.log(`Models: ${result.modelCount}`);
-    }
-    if (result.defaultModel) {
-      console.log(`Default: ${result.defaultModel}`);
-    }
-    if (result.modelClasses && result.modelClasses.length > 0) {
-      console.log(`Model classes: ${result.modelClasses.join(", ")}`);
-    }
-    if (result.webSearchModels && result.webSearchModels.length > 0) {
-      console.log(`Web search: ${result.webSearchModels.join(", ")}`);
-    }
-    if (result.webSearchRouteCandidates && result.webSearchRouteCandidates.length > 0) {
-      console.log(`Web search routes: ${result.webSearchRouteCandidates.join(", ")}`);
-    }
-    if (result.fileCapabilityModels && result.fileCapabilityModels.length > 0) {
-      console.log(`File capabilities: ${result.fileCapabilityModels.join(", ")}`);
-    }
-    if (result.toolModelRoutes && result.toolModelRoutes.length > 0) {
-      console.log(`Tool model routes: ${result.toolModelRoutes.join(", ")}`);
-    }
-    if (parsed.probe) {
-      const probe = await probeModelsConfig({ path: parsed.path, probe: parsed.probe });
-      console.log(`Probe ${probe.purpose}: ${probe.message}`);
-      for (const attempt of probe.attempts) {
-        console.log(`- ${attempt.status} ${attempt.route} sources=${attempt.sourceCount}${attempt.failureCategory ? ` failure=${attempt.failureCategory}` : ""}`);
-      }
-      if (probe.status === "failed") process.exitCode = 1;
-    }
-    return;
-  }
-  console.log(`Usage:
-  pie models init [--path <path>] [--force] [--stdout]
-  pie models validate [--path <path>] [--probe web_search] [--json]`);
-}
 async function runWithJsonEventsConsoleIsolation(fn) {
   const originalLog = console.log;
   const originalInfo = console.info;
@@ -73099,7 +74271,21 @@ async function runWithJsonEventsConsoleIsolation(fn) {
 }
 async function createCliTestStreamFnFromEnv() {
   if (!process.env.PIE_TEST_MOCK_STREAM_SEQUENCE) return void 0;
-  return (await import("./chunks/test-stream-XCE2KXJU.js")).createTestStreamFnFromSequenceEnv();
+  return (await import("./chunks/test-stream-5T7E7C25.js")).createTestStreamFnFromSequenceEnv();
+}
+function resolveJsonEventsDetailFlag() {
+  for (let index = 0; index < process.argv.length; index += 1) {
+    const arg = process.argv[index];
+    if (arg === "--event-detail") {
+      const raw = process.argv[index + 1] ?? "";
+      return raw === "compact" || raw === "full" ? { value: raw } : { error: raw || "(missing)" };
+    }
+    if (arg.startsWith("--event-detail=")) {
+      const raw = arg.slice("--event-detail=".length);
+      return raw === "compact" || raw === "full" ? { value: raw } : { error: raw };
+    }
+  }
+  return { value: "compact" };
 }
 async function startChat(initialPrompt, testCommand) {
   const rawOutput = process.argv.includes("--raw-output");
@@ -73111,6 +74297,12 @@ async function startChat(initialPrompt, testCommand) {
   const extensionPaths = parseRepeatedFlag(process.argv, "--extension-path");
   const extensionFlags = parseExtensionFlags(process.argv);
   if (jsonEvents) {
+    const detailFlag = resolveJsonEventsDetailFlag();
+    if ("error" in detailFlag) {
+      console.error(`Invalid --event-detail value: ${detailFlag.error}. Use compact or full.`);
+      process.exit(2);
+    }
+    const eventDetail = detailFlag.value;
     let developerInstructions;
     try {
       developerInstructions = resolveDeveloperInstructionsFromArgs(process.argv);
@@ -73124,7 +74316,8 @@ async function startChat(initialPrompt, testCommand) {
           explicitSessionId,
           resumeRequired,
           developerInstructions,
-          mockResponse: process.env.PIE_TEST_MOCK_RESPONSE
+          mockResponse: process.env.PIE_TEST_MOCK_RESPONSE,
+          eventDetail
         });
         return;
       }
@@ -73132,6 +74325,7 @@ async function startChat(initialPrompt, testCommand) {
         explicitSessionId,
         resumeRequired,
         developerInstructions,
+        eventDetail,
         streamFn: await createCliTestStreamFnFromEnv(),
         createRuntime: async ({ cwd, sessionId }) => composeCliRuntime({
           explicitSessionId: explicitSessionId ?? sessionId,
@@ -73218,6 +74412,16 @@ async function main() {
     console.log(VERSION);
     return;
   }
+  if (args.length === 0 && !process.stdin.isTTY) {
+    console.error("pie: no arguments and stdin is not a terminal; refusing to start interactive mode.");
+    showHelp();
+    process.exitCode = 1;
+    return;
+  }
+  if (args[0] === STABLE_CLI_COMMANDS.capabilities) {
+    runCapabilitiesCommand(args.slice(1));
+    return;
+  }
   if (args[0] === STABLE_CLI_COMMANDS.doctor) {
     await runDoctorCommand(args.slice(1));
     return;
@@ -73240,7 +74444,7 @@ async function main() {
     return;
   }
   if (args[0] === STABLE_CLI_COMMANDS.permissions) {
-    console.log(formatPermissionsHelp());
+    runPermissionsCommand(args.slice(1));
     return;
   }
   const parsed = parseCliInvocation(args);