@wrongstack/core 0.287.0 → 0.291.0

package/dist/utils/index.js

@@ -167,7 +167,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
   const dir = path.dirname(targetPath);
   await fs.mkdir(dir, { recursive: true });
   const lockPath = path.join(dir, `.${path.basename(targetPath)}.lock`);
-  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const timeoutMs = opts.timeoutMs ?? 15e3;
   const staleMs = opts.staleMs ?? 3e4;
   const started = Date.now();
   let handle;
@@ -177,6 +177,13 @@ async function withFileLock(targetPath, fn, opts = {}) {
       await handle.writeFile(`${process.pid}:${Date.now()}`);
       break;
     } catch (err) {
+      if (handle) {
+        await handle.close().catch(() => {
+        });
+        await fs.unlink(lockPath).catch(() => {
+        });
+        handle = void 0;
+      }
       const code = err.code;
       if (code === "ENOENT") {
         await fs.mkdir(dir, { recursive: true });
@@ -426,64 +433,222 @@ function buildChildEnv(optsOrSessionId) {
 
 // src/utils/term.ts
 var hasStdout = () => typeof process !== "undefined" && !!process.stdout;
-var hasStdin = () => typeof process !== "undefined" && !!process.stdin;
 function isStdoutTTY() {
   return hasStdout() && Boolean(process.stdout.isTTY);
 }
-function isStdinTTY() {
-  return hasStdin() && Boolean(process.stdin.isTTY);
-}
-function isInteractive() {
-  return isStdinTTY() && isStdoutTTY();
-}
-function getTermSize() {
-  if (!hasStdout()) return { rows: 24, cols: 80 };
+function parseColorDepth(env) {
+  if (env.FORCE_COLOR === "0") return 0;
+  if (env.FORCE_COLOR !== void 0) return 3;
+  if (typeof env.NO_COLOR === "string" && env.NO_COLOR !== "") return 0;
+  const colorterm = (env.COLORTERM ?? "").toLowerCase();
+  if (colorterm === "truecolor" || colorterm === "24bit") return 3;
+  const term = (env.TERM ?? "").toLowerCase();
+  if (term.includes("truecolor") || term.includes("24bit")) return 3;
+  if (term.includes("256color")) return 2;
+  if (term === "dumb") return 0;
+  return 1;
+}
+function parseMouseProtocol(term) {
+  const t = term.toLowerCase();
+  if (t.startsWith("xterm") || t.startsWith("tmux") || t.startsWith("screen") || t.includes("rxvt-unicode") || t.includes("urxvt") || t.includes("konsole") || t.includes("gnome") || t.includes("foot") || t.includes("alacritty") || t.includes("wezterm") || t.includes("kitty") || t.includes("vscode") || t.includes("Apple_Terminal")) {
+    return "sgr";
+  }
+  if (t.startsWith("rxvt") || t.startsWith("linux") || t.includes("Eterm")) {
+    return "urxvt";
+  }
+  if (t === "vt100" || t === "dumb") return "none";
+  return "sgr";
+}
+function detectTerminal(opts = {}) {
+  const stdin = opts.stdin ?? process.stdin;
+  const stdout = opts.stdout ?? process.stdout;
+  const env = opts.env ?? process.env;
+  const isRealTTY = (stdin?.isTTY ?? false) && (stdout?.isTTY ?? false);
+  const stdoutWritable = isRealTTY && typeof stdout?.write === "function";
+  const term = env.TERM ?? "";
+  const isTmux = term.toLowerCase().startsWith("tmux");
+  const isWindowsConhost = isRealTTY && process.platform === "win32" && typeof stdout.getColorDepth !== "function";
   return {
-    rows: process.stdout.rows ?? 24,
-    cols: process.stdout.columns ?? 80
+    isRealTTY,
+    colorDepth: isRealTTY ? parseColorDepth(env) : 0,
+    stdoutWritable,
+    mouseProtocol: parseMouseProtocol(term),
+    canSetTitle: isRealTTY && term !== "dumb",
+    isTmux,
+    isWindowsConhost
   };
 }
-function onResize(cb, stream = process.stdout) {
-  if (!stream || typeof stream.on !== "function") return () => {
-  };
-  const handler = () => {
-    cb({
-      rows: stream.rows ?? 24,
-      cols: stream.columns ?? 80
-    });
-  };
-  stream.on("resize", handler);
-  return () => {
-    stream.off("resize", handler);
-  };
-}
-function setRawMode(input, mode) {
-  if (input?.isTTY !== true) return false;
-  if (typeof input.setRawMode !== "function") return false;
-  input.setRawMode(mode);
-  return true;
-}
-var activeOutputGuard = null;
-function setOutputLineGuard(guard) {
-  activeOutputGuard = guard;
-}
-function writeTo(s, stream) {
-  if (!stream || typeof stream.write !== "function") return false;
-  const guard = activeOutputGuard;
-  if (!guard) {
-    stream.write(s);
+var TerminalLifecycle = class {
+  _active = false;
+  /**
+   * The stdin stream we took raw mode on. Set by `acquire()`; undefined before
+   * first call. Used by `release()` and by the ConPTY race-closer in
+   * `acquire()`.
+   */
+  _stdin;
+  /**
+   * The `isRaw` snapshot captured before the first `acquire()` call, so
+   * `release()` restores to the pre-TUI state rather than blindly disabling
+   * raw mode. Null when `acquire()` has never been called.
+   */
+  _wasRaw = null;
+  /**
+   * Request the process to exit. Set the flag, trigger any registered
+   * `onRequestExit` callback (typically Ink's `unmount()`), and arm a
+   * deadline timer.  When the timer fires the process is hard-exited.
+   *
+   * Safe to call multiple times: subsequent calls no-op after the first.
+   */
+  requestExit;
+  /**
+   * Callback invoked when `requestExit` is called. Registered by the Ink
+   * mount point so unmount() runs before the deadline timer fires.
+   */
+  onRequestExit = null;
+  constructor() {
+    let exitCode = 0;
+    let requested = false;
+    this.requestExit = (code = 0) => {
+      exitCode = code;
+      if (requested) return;
+      requested = true;
+      try {
+        this.onRequestExit?.();
+      } catch {
+      }
+      setTimeout(() => process.exit(exitCode), 5e3).unref();
+    };
+  }
+  /** True while raw mode is held. */
+  get active() {
+    return this._active;
+  }
+  /**
+   * Acquire raw mode on `stdin`. Idempotent — calling twice is safe; only the
+   * first call has any effect.
+   *
+   * On Windows ConPTY, calls `setRawMode` twice: once immediately, then again
+   * after the next event-loop tick. This closes the ConPTY race where
+   * `readline`'s cleanup (registered before this class is constructed) can
+   * restore the original cooked mode after we set raw mode but before Ink's
+   * render loop takes over the stdin fd. The double-call ensures the last
+   * writer wins.
+   *
+   * @param stdin - The stdin stream (defaults to `process.stdin`).
+   * @returns `true` if raw mode was acquired; `false` if stdin is not a TTY
+   *          or already shut down.
+   */
+  acquire(stdin = process.stdin) {
+    if (this._active) return false;
+    if (stdin?.isTTY !== true) return false;
+    if (typeof stdin.setRawMode !== "function") return false;
+    this._wasRaw = stdin.isRaw ?? false;
+    this._stdin = stdin;
+    stdin.setRawMode(true);
+    this._active = true;
+    if (process.platform === "win32") {
+      setImmediate(() => {
+        if (this._active && this._stdin?.isTTY) {
+          this._stdin.setRawMode?.(true);
+        }
+      });
+    }
     return true;
   }
-  guard.suspend();
-  stream.write(s);
-  guard.resume();
-  return true;
+  /**
+   * Release raw mode and restore the terminal to the state it was in before
+   * `acquire()` was called. Idempotent — subsequent calls are no-ops.
+   *
+   * Call this on: SIGINT, SIGTERM, SIGHUP, SIGBREAK, and `process.exit`.
+   *
+   * ⚠ **Windows caveat**: `setRawMode(false)` on ConPTY restores the original
+   * console mode captured when the process started — not the mode captured by
+   * `acquire()`. On ConPTY, the original mode was already raw (ConPTY starts
+   * raw), so this call is typically a no-op on Windows Terminal. On conhost.exe
+   * it may restore cooked mode, which is correct for that backend.
+   */
+  release() {
+    if (!this._active) return;
+    this._active = false;
+    const stdin = this._stdin;
+    if (stdin?.isTTY === true) {
+      stdin.setRawMode?.(this._wasRaw ?? false);
+    }
+    this._stdin = void 0;
+    this._wasRaw = null;
+  }
+  /**
+   * Synchronously reset all terminal state written by the TUI layer:
+   * raw mode, SGR attributes, cursor visibility, and mouse tracking.
+   *
+   * Intended for the final `process.on('exit')` handler where async is
+   * impossible. Uses `\x1b[0m` (SGR reset), `\x1b[?25h` (cursor show),
+   * and `\x1b[?9l` (mouse off) — all safe to emit even if the terminal does
+   * not understand them (unknown CSI sequences are silently ignored).
+   *
+   * Safe to call multiple times from multiple exit paths because each write
+   * is a constant-time synchronous stream write.
+   *
+   * @param stdout - Stream to reset (defaults to `process.stdout`).
+   */
+  reset(stdout = process.stdout) {
+    if (typeof stdout?.write !== "function") return;
+    stdout.write("\x1B[0m");
+    stdout.write("\x1B[?25h");
+    stdout.write("\x1B[?1003l\x1B[?1002l\x1B[?1000l");
+  }
+};
+var ESCAPE_TERMINATOR = Object.freeze({
+  BEL: "\x07",
+  // OSC 0 / OSC 2 (title)
+  ST: "\x1B\\"
+  // DCS / strict OSC
+});
+function safeEmit(sequence, stdout = process.stdout) {
+  const raw = typeof sequence === "string" ? sequence : sequence.raw;
+  const term = typeof sequence === "string" ? void 0 : sequence.terminator;
+  if (!raw) {
+    return { ok: false, reason: "empty" };
+  }
+  if (stdout?.isTTY !== true) {
+    return { ok: false, reason: "not_a_tty" };
+  }
+  if (raw.startsWith("\x1B]") || raw.startsWith("\x1BP")) {
+    if (!term) {
+      void term;
+      const safe = `${raw}\x07`;
+      try {
+        stdout.write(safe);
+      } catch {
+        return { ok: false, reason: "unwritable" };
+      }
+      return { ok: true, reason: "empty" };
+    }
+    try {
+      stdout.write(`${raw}${term}`);
+    } catch {
+      return { ok: false, reason: "unwritable" };
+    }
+    return { ok: true, reason: "empty" };
+  }
+  try {
+    stdout.write(raw);
+  } catch {
+    return { ok: false, reason: "unwritable" };
+  }
+  return { ok: true, reason: "empty" };
 }
-function writeOut(s, stream = process.stdout) {
-  return writeTo(s, stream);
+function buildTitleSequence(title, terminator = ESCAPE_TERMINATOR.BEL) {
+  return {
+    raw: `\x1B]0;${title.replace(/\x07/g, "")}`,
+    terminator
+  };
 }
-function writeErr(s, stream = process.stderr) {
-  return writeTo(s, stream);
+function buildSgrSequence(...codes) {
+  return { raw: `\x1B[${codes.join(";")}m` };
+}
+function setTitle(title, stdout = process.stdout) {
+  return safeEmit(buildTitleSequence(title), stdout).ok;
 }
 
 // src/utils/color.ts
@@ -1953,6 +2118,16 @@ function stripUndefined(obj) {
 }
 
 // src/utils/message-invariants.ts
+function hasMeaningfulContent(content) {
+  if (typeof content === "string") return content.trim().length > 0;
+  return content.some((block) => {
+    if (block.type === "text") return block.text.trim().length > 0;
+    if (block.type === "thinking") {
+      return block.thinking.trim().length > 0 || Boolean(block.signature);
+    }
+    return true;
+  });
+}
 function repairToolUseAdjacency(messages) {
   const removedToolUses = [];
   const removedToolResults = [];
@@ -2040,8 +2215,7 @@ function mapContent(msg, fn) {
   return { ...msg, content: next };
 }
 function isEmptyMessage(msg) {
-  if (typeof msg.content === "string") return msg.content.trim().length === 0;
-  return msg.content.length === 0;
+  return !hasMeaningfulContent(msg.content);
 }
 
 // src/utils/newline-normalize.ts
@@ -2114,7 +2288,7 @@ function compileUserRegex(pattern, flags) {
 
 // src/utils/safe-json.ts
 function safeParse(input, maxBytes = 5e6) {
-  if (input.length > maxBytes) {
+  if (Buffer.byteLength(input, "utf8") > maxBytes) {
     return { ok: false, error: `Input exceeds limit (${maxBytes} bytes)` };
   }
   try {
@@ -2149,7 +2323,7 @@ function safeStringify(value, pretty = false) {
 }
 function sanitizeJsonString(s) {
   let out = s.trim();
-  out = stripSingleLineComments(out);
+  out = stripJsonComments(out);
   out = out.replace(/,(\s*[}\]])/g, "$1");
   out = escapeControlCharsInStrings(out);
   try {
@@ -2207,20 +2381,45 @@ function escapeControlCharsInStrings(s) {
   }
   return out;
 }
-function stripSingleLineComments(s) {
+function stripJsonComments(s) {
   let inString = false;
+  let escaped = false;
   const chars = [];
   let i = 0;
   while (i < s.length) {
     const c = s.charAt(i);
-    if (c === '"' && (i === 0 || s.charAt(i - 1) !== "\\")) {
-      inString = !inString;
+    if (inString) {
       chars.push(c);
-    } else if (c === "/" && s.charAt(i + 1) === "/" && !inString) {
-      while (i < s.length && s.charAt(i) !== "\n") i++;
-    } else {
+      if (escaped) {
+        escaped = false;
+      } else if (c === "\\") {
+        escaped = true;
+      } else if (c === '"') {
+        inString = false;
+      }
+      i++;
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
       chars.push(c);
+      i++;
+      continue;
+    }
+    if (c === "/" && s.charAt(i + 1) === "/") {
+      while (i < s.length && s.charAt(i) !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && s.charAt(i + 1) === "*") {
+      const end = s.indexOf("*/", i + 2);
+      if (end === -1) {
+        chars.push(s.slice(i));
+        break;
+      }
+      i = end + 2;
+      continue;
     }
+    chars.push(c);
     i++;
   }
   return chars.join("");
@@ -2248,51 +2447,16 @@ function invalid(sessionId) {
   });
 }
 
-// src/utils/slug.ts
-function slugify(name, fallback = "prompt", maxLen = 64) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/g, "") || fallback;
-}
-
-// src/utils/ulid.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-var ENCODING_LEN = ENCODING.length;
-var TIME_LEN = 10;
-var RANDOM_LEN = 16;
-function encodeTime(now, len) {
-  let mod;
-  let str = "";
-  for (let i = len - 1; i >= 0; i--) {
-    mod = now % ENCODING_LEN;
-    str = ENCODING[mod] + str;
-    now = (now - mod) / ENCODING_LEN;
-  }
-  return str;
-}
-function encodeRandom(len) {
-  const bytes = randomBytes2(len);
-  let str = "";
-  for (let i = 0; i < len; i++) {
-    str += ENCODING[bytes[i] % ENCODING_LEN];
-  }
-  return str;
-}
-function ulid(seedTime = Date.now()) {
-  return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN);
-}
-function isUlid(value) {
-  if (value.length !== TIME_LEN + RANDOM_LEN) return false;
-  for (const ch of value) {
-    if (!ENCODING.includes(ch)) return false;
-  }
-  return true;
-}
-
 // src/utils/sleep.ts
 function sleep(ms) {
   return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 
+// src/utils/slug.ts
+function slugify(name, fallback = "prompt", maxLen = 64) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/g, "") || fallback;
+}
+
 // src/utils/string.ts
 function truncate(s, max) {
   return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
@@ -2426,41 +2590,6 @@ function hasOpenTodos(todos) {
   return todos.some((t) => t.status === "pending" || t.status === "in_progress");
 }
 
-// src/utils/tool-subject.ts
-var GLOB_METACHARACTERS = /[*?[\]]/g;
-function escapeGlobSubject(value) {
-  return value.replace(GLOB_METACHARACTERS, (char) => `\\${char}`);
-}
-function normalizePathSubject(value) {
-  return escapeGlobSubject(value.replace(/\\/g, "/"));
-}
-function isPathSubjectKey(subjectKey) {
-  return subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
-}
-function subjectForToolInput(toolName, input, subjectKey) {
-  if (!input || typeof input !== "object") return void 0;
-  const obj = input;
-  if (subjectKey) {
-    const value = obj[subjectKey];
-    if (typeof value === "string") {
-      return isPathSubjectKey(subjectKey) ? normalizePathSubject(value) : escapeGlobSubject(value);
-    }
-  }
-  if (toolName === "bash" && typeof obj.command === "string") {
-    return escapeGlobSubject(obj.command);
-  }
-  if (typeof obj.path === "string") {
-    return normalizePathSubject(obj.path);
-  }
-  if (typeof obj.url === "string") {
-    return escapeGlobSubject(obj.url);
-  }
-  if (typeof obj.name === "string") {
-    return escapeGlobSubject(obj.name);
-  }
-  return void 0;
-}
-
 // src/utils/tool-wire-compact.ts
 var TOOL_DESCRIPTION_MAX_CHARS = 400;
 var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
@@ -2477,9 +2606,11 @@ function compactToolDefinitionForWire(tool, opts = {}) {
       tool.description ?? "",
       opts.descriptionMaxChars ?? TOOL_DESCRIPTION_MAX_CHARS
     ),
-    inputSchema: compactSchemaDescriptions(
-      tool.inputSchema,
-      opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
+    inputSchema: normalizeTopLevelToolSchema(
+      compactSchemaDescriptions(
+        tool.inputSchema,
+        opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
+      )
     )
   };
   if (useDefaultOptions && typeof tool === "object" && tool !== null) {
@@ -2487,6 +2618,44 @@ function compactToolDefinitionForWire(tool, opts = {}) {
   }
   return compact;
 }
+function normalizeTopLevelToolSchema(schema) {
+  const combinators = ["oneOf", "anyOf", "allOf"].map((keyword) => ({ keyword, branches: schema[keyword] })).filter(
+    (entry) => Array.isArray(entry.branches)
+  );
+  if (combinators.length === 0) return schema;
+  const out = { ...schema, type: "object" };
+  delete out["oneOf"];
+  delete out["anyOf"];
+  delete out["allOf"];
+  const properties = isRecord(schema["properties"]) ? { ...schema["properties"] } : {};
+  let required = stringSet(schema["required"]);
+  for (const { keyword, branches } of combinators) {
+    const objectBranches = branches.filter(isRecord);
+    for (const branch of objectBranches) {
+      if (isRecord(branch["properties"])) Object.assign(properties, branch["properties"]);
+    }
+    const branchRequired = objectBranches.map((branch) => stringSet(branch["required"]));
+    if (keyword === "allOf") {
+      for (const fields of branchRequired) for (const field of fields) required.add(field);
+    } else if (branchRequired.length > 0) {
+      const common = new Set(
+        [...branchRequired[0]].filter(
+          (field) => branchRequired.slice(1).every((fields) => fields.has(field))
+        )
+      );
+      required = /* @__PURE__ */ new Set([...required, ...common]);
+    }
+  }
+  out["properties"] = properties;
+  if (required.size > 0) out["required"] = [...required];
+  else delete out["required"];
+  return out;
+}
+function stringSet(value) {
+  return new Set(
+    Array.isArray(value) ? value.filter((item) => typeof item === "string") : []
+  );
+}
 function compactSchemaDescriptions(schema, maxDescriptionChars = SCHEMA_DESCRIPTION_MAX_CHARS) {
   const compact = compactSchemaNode(schema, maxDescriptionChars);
   return isRecord(compact) ? compact : { type: "object", properties: {} };
@@ -2727,6 +2896,114 @@ function resetCalibration(calibrationKey) {
   _cals.delete(calibrationKey);
 }
 
+// src/utils/tool-description-mode.ts
+var DEFAULT_TOOL_DESCRIPTION_MODE = "extend";
+var ORIGINAL_TOOL_DESCRIPTION = /* @__PURE__ */ Symbol.for("wrongstack.tool.originalDescription");
+function normalizeToolDescriptionMode(value) {
+  if (typeof value !== "string") return void 0;
+  const raw = value.trim().toLowerCase();
+  if (raw === "extend" || raw === "extended" || raw === "full") return "extend";
+  if (raw === "simple" || raw === "short" || raw === "brief") return "simple";
+  return void 0;
+}
+function resolveToolDescriptionMode(modes, toolName) {
+  return normalizeToolDescriptionMode(modes?.[toolName]) ?? DEFAULT_TOOL_DESCRIPTION_MODE;
+}
+function simplifyToolDescription(text, opts = {}) {
+  const maxSentences = Math.max(1, opts.maxSentences ?? 2);
+  const maxChars = Math.max(40, opts.maxChars ?? 180);
+  const normalized = text.replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxChars) return normalized;
+  const sentences = normalized.match(/[^.!?]+[.!?]+(?=\s|$)|[^.!?]+$/g) ?? [normalized];
+  const selected = [];
+  for (const sentence of sentences) {
+    selected.push(sentence.trim());
+    const candidate = selected.join(" ");
+    if (selected.length >= maxSentences || candidate.length >= maxChars) break;
+  }
+  const summary = selected.join(" ").trim() || normalized;
+  if (summary.length <= maxChars) return summary;
+  const hardLimit = maxChars - 4;
+  const boundary = findWordBoundary(summary, hardLimit);
+  return `${summary.slice(0, boundary > 0 ? boundary : hardLimit).trimEnd()} ...`;
+}
+function applyToolDescriptionModeToTool(tool, mode) {
+  const existingOriginal = getOriginalDescription(tool);
+  if (mode === "extend" && !existingOriginal) return tool;
+  const original = existingOriginal ?? {
+    description: tool.description,
+    usageHint: tool.usageHint
+  };
+  const next = mode === "simple" ? withDescription(tool, {
+    description: simplifyToolDescription(original.description),
+    usageHint: original.usageHint === void 0 ? void 0 : simplifyToolDescription(original.usageHint)
+  }) : withDescription(tool, original);
+  return attachOriginalDescription(next, original);
+}
+function setToolDescriptionMode(registry, name, mode) {
+  if (typeof registry.setDescriptionMode === "function") {
+    return registry.setDescriptionMode(name, mode);
+  }
+  if (!registry.get(name) || typeof registry.wrap !== "function") return false;
+  registry.wrap(
+    name,
+    (tool) => applyToolDescriptionModeToTool(tool, mode),
+    "tool-description-mode"
+  );
+  return true;
+}
+function getToolDescriptionMode(registry, name) {
+  return registry.getDescriptionMode?.(name) ?? DEFAULT_TOOL_DESCRIPTION_MODE;
+}
+function applyToolDescriptionModes(registry, modes) {
+  if (typeof registry.applyDescriptionModes === "function") {
+    return registry.applyDescriptionModes(modes);
+  }
+  const entries = Object.entries(modes ?? {});
+  const missing = [];
+  let applied = 0;
+  for (const [name, rawMode] of entries) {
+    const mode = normalizeToolDescriptionMode(rawMode);
+    if (!mode) continue;
+    if (setToolDescriptionMode(registry, name, mode)) applied++;
+    else missing.push(name);
+  }
+  return { applied, missing };
+}
+function getOriginalDescription(tool) {
+  return tool[ORIGINAL_TOOL_DESCRIPTION];
+}
+function attachOriginalDescription(tool, original) {
+  Object.defineProperty(tool, ORIGINAL_TOOL_DESCRIPTION, {
+    configurable: true,
+    enumerable: false,
+    value: original,
+    writable: true
+  });
+  return tool;
+}
+function withDescription(tool, next) {
+  const copy = {
+    ...tool,
+    description: next.description,
+    usageHint: next.usageHint
+  };
+  if (next.usageHint === void 0) {
+    delete copy.usageHint;
+  }
+  return copy;
+}
+function findWordBoundary(text, limit) {
+  const semantic = Math.max(
+    text.lastIndexOf(". ", limit),
+    text.lastIndexOf("; ", limit),
+    text.lastIndexOf(", ", limit)
+  );
+  if (semantic > 40) return semantic + 1;
+  const space = text.lastIndexOf(" ", limit);
+  return space > 40 ? space : limit;
+}
+
 // src/utils/tool-output-serializer.ts
 var DEFAULT_LIST_LIMIT = 500;
 var LOG_ENTRY_LIMIT = 200;
@@ -3390,114 +3667,6 @@ function isScalar(value) {
   return value === null || ["string", "number", "boolean"].includes(typeof value);
 }
 
-// src/utils/tool-description-mode.ts
-var DEFAULT_TOOL_DESCRIPTION_MODE = "extend";
-var ORIGINAL_TOOL_DESCRIPTION = /* @__PURE__ */ Symbol.for("wrongstack.tool.originalDescription");
-function normalizeToolDescriptionMode(value) {
-  if (typeof value !== "string") return void 0;
-  const raw = value.trim().toLowerCase();
-  if (raw === "extend" || raw === "extended" || raw === "full") return "extend";
-  if (raw === "simple" || raw === "short" || raw === "brief") return "simple";
-  return void 0;
-}
-function resolveToolDescriptionMode(modes, toolName) {
-  return normalizeToolDescriptionMode(modes?.[toolName]) ?? DEFAULT_TOOL_DESCRIPTION_MODE;
-}
-function simplifyToolDescription(text, opts = {}) {
-  const maxSentences = Math.max(1, opts.maxSentences ?? 2);
-  const maxChars = Math.max(40, opts.maxChars ?? 180);
-  const normalized = text.replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
-  if (normalized.length <= maxChars) return normalized;
-  const sentences = normalized.match(/[^.!?]+[.!?]+(?=\s|$)|[^.!?]+$/g) ?? [normalized];
-  const selected = [];
-  for (const sentence of sentences) {
-    selected.push(sentence.trim());
-    const candidate = selected.join(" ");
-    if (selected.length >= maxSentences || candidate.length >= maxChars) break;
-  }
-  const summary = selected.join(" ").trim() || normalized;
-  if (summary.length <= maxChars) return summary;
-  const hardLimit = maxChars - 4;
-  const boundary = findWordBoundary(summary, hardLimit);
-  return `${summary.slice(0, boundary > 0 ? boundary : hardLimit).trimEnd()} ...`;
-}
-function applyToolDescriptionModeToTool(tool, mode) {
-  const existingOriginal = getOriginalDescription(tool);
-  if (mode === "extend" && !existingOriginal) return tool;
-  const original = existingOriginal ?? {
-    description: tool.description,
-    usageHint: tool.usageHint
-  };
-  const next = mode === "simple" ? withDescription(tool, {
-    description: simplifyToolDescription(original.description),
-    usageHint: original.usageHint === void 0 ? void 0 : simplifyToolDescription(original.usageHint)
-  }) : withDescription(tool, original);
-  return attachOriginalDescription(next, original);
-}
-function setToolDescriptionMode(registry, name, mode) {
-  if (typeof registry.setDescriptionMode === "function") {
-    return registry.setDescriptionMode(name, mode);
-  }
-  if (!registry.get(name) || typeof registry.wrap !== "function") return false;
-  registry.wrap(
-    name,
-    (tool) => applyToolDescriptionModeToTool(tool, mode),
-    "tool-description-mode"
-  );
-  return true;
-}
-function getToolDescriptionMode(registry, name) {
-  return registry.getDescriptionMode?.(name) ?? DEFAULT_TOOL_DESCRIPTION_MODE;
-}
-function applyToolDescriptionModes(registry, modes) {
-  if (typeof registry.applyDescriptionModes === "function") {
-    return registry.applyDescriptionModes(modes);
-  }
-  const entries = Object.entries(modes ?? {});
-  const missing = [];
-  let applied = 0;
-  for (const [name, rawMode] of entries) {
-    const mode = normalizeToolDescriptionMode(rawMode);
-    if (!mode) continue;
-    if (setToolDescriptionMode(registry, name, mode)) applied++;
-    else missing.push(name);
-  }
-  return { applied, missing };
-}
-function getOriginalDescription(tool) {
-  return tool[ORIGINAL_TOOL_DESCRIPTION];
-}
-function attachOriginalDescription(tool, original) {
-  Object.defineProperty(tool, ORIGINAL_TOOL_DESCRIPTION, {
-    configurable: true,
-    enumerable: false,
-    value: original,
-    writable: true
-  });
-  return tool;
-}
-function withDescription(tool, next) {
-  const copy = {
-    ...tool,
-    description: next.description,
-    usageHint: next.usageHint
-  };
-  if (next.usageHint === void 0) {
-    delete copy.usageHint;
-  }
-  return copy;
-}
-function findWordBoundary(text, limit) {
-  const semantic = Math.max(
-    text.lastIndexOf(". ", limit),
-    text.lastIndexOf("; ", limit),
-    text.lastIndexOf(", ", limit)
-  );
-  if (semantic > 40) return semantic + 1;
-  const space = text.lastIndexOf(" ", limit);
-  return space > 40 ? space : limit;
-}
-
 // src/utils/tool-result-render-mode.ts
 var DEFAULT_TOOL_RESULT_RENDER_MODE = "extend";
 function normalizeToolResultRenderMode(value) {
@@ -3535,6 +3704,76 @@ function applyToolResultRenderModes(registry, modes) {
   return { applied, missing };
 }
 
+// src/utils/tool-subject.ts
+var GLOB_METACHARACTERS = /[*?[\]]/g;
+function escapeGlobSubject(value) {
+  return value.replace(GLOB_METACHARACTERS, (char) => `\\${char}`);
+}
+function normalizePathSubject(value) {
+  return escapeGlobSubject(value.replace(/\\/g, "/"));
+}
+function isPathSubjectKey(subjectKey) {
+  return subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
+}
+function subjectForToolInput(toolName, input, subjectKey) {
+  if (!input || typeof input !== "object") return void 0;
+  const obj = input;
+  if (subjectKey) {
+    const value = obj[subjectKey];
+    if (typeof value === "string") {
+      return isPathSubjectKey(subjectKey) ? normalizePathSubject(value) : escapeGlobSubject(value);
+    }
+  }
+  if (toolName === "bash" && typeof obj.command === "string") {
+    return escapeGlobSubject(obj.command);
+  }
+  if (typeof obj.path === "string") {
+    return normalizePathSubject(obj.path);
+  }
+  if (typeof obj.url === "string") {
+    return escapeGlobSubject(obj.url);
+  }
+  if (typeof obj.name === "string") {
+    return escapeGlobSubject(obj.name);
+  }
+  return void 0;
+}
+
+// src/utils/ulid.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ENCODING_LEN = ENCODING.length;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function encodeTime(now, len) {
+  let mod;
+  let str = "";
+  for (let i = len - 1; i >= 0; i--) {
+    mod = now % ENCODING_LEN;
+    str = ENCODING[mod] + str;
+    now = (now - mod) / ENCODING_LEN;
+  }
+  return str;
+}
+function encodeRandom(len) {
+  const bytes = randomBytes2(len);
+  let str = "";
+  for (let i = 0; i < len; i++) {
+    str += ENCODING[bytes[i] % ENCODING_LEN];
+  }
+  return str;
+}
+function ulid(seedTime = Date.now()) {
+  return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN);
+}
+function isUlid(value) {
+  if (value.length !== TIME_LEN + RANDOM_LEN) return false;
+  for (const ch of value) {
+    if (!ENCODING.includes(ch)) return false;
+  }
+  return true;
+}
+
 // src/utils/wstack-paths.ts
 import { createHash } from "node:crypto";
 import * as fs3 from "node:fs";
@@ -3587,6 +3826,11 @@ function resolveWstackPaths(opts) {
     homeDir,
     configDir: globalRoot,
     globalConfig: path4.join(globalRoot, "config.json"),
+    profilesDir: path4.join(globalRoot, "profiles"),
+    profileConfig: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path4.join(globalRoot, "profiles", safe || "default", "config.json");
+    },
     secretsKey: path4.join(globalRoot, ".key"),
     globalMemory: path4.join(globalRoot, "memory.md"),
     globalSkills: path4.join(globalRoot, "skills"),
@@ -3633,10 +3877,12 @@ export {
   COMPLETED_WORK_LEDGER_MARKER,
   DEFAULT_TOOL_DESCRIPTION_MODE,
   DEFAULT_TOOL_RESULT_RENDER_MODE,
+  ESCAPE_TERMINATOR,
   FORBIDDEN_PROTO_KEYS,
   IncomingImageError,
   MAX_INCOMING_IMAGES,
   MAX_INCOMING_IMAGE_BYTES,
+  TerminalLifecycle,
   applyToolDescriptionModeToTool,
   applyToolDescriptionModes,
   applyToolResultRenderModes,
@@ -3646,6 +3892,8 @@ export {
   buildChildEnv,
   buildCompletedWorkLedgerBlock,
   buildContextEvidenceDigest,
+  buildSgrSequence,
+  buildTitleSequence,
   buildUserContentBlocks,
   canonicalProjectRoot,
   coerceAgainstSchema,
@@ -3662,6 +3910,7 @@ export {
   createToolOutputSerializer,
   deepMerge,
   detectNewlineStyle,
+  detectTerminal,
   ensureDir,
   escapeGlobSubject,
   estimateMessageTokens,
@@ -3681,18 +3930,15 @@ export {
   getCalibrationState,
   getChildEnvGitIdentity,
   getJsonPath,
-  getTermSize,
   getToolDescriptionMode,
   getToolResultRenderMode,
+  hasMeaningfulContent,
   hasOpenTodos,
-  isInteractive,
   isJsonObject,
   isPathSubjectKey,
   isPrimitiveArray,
   isPrivateIPv4,
   isPrivateIPv6,
-  isStdinTTY,
-  isStdoutTTY,
   isUlid,
   jsonObjectFileExists,
   markAssistantReferencedEvidence,
@@ -3704,7 +3950,6 @@ export {
   normalizeToLf,
   normalizeToolDescriptionMode,
   normalizeToolResultRenderMode,
-  onResize,
   parseIncomingImages,
   projectHash,
   projectSlug,
@@ -3721,6 +3966,7 @@ export {
   resolveToolDescriptionMode,
   resolveToolResultRenderMode,
   resolveWstackPaths,
+  safeEmit,
   safeParse,
   safeStringify,
   sanitizeJsonString,
@@ -3728,8 +3974,7 @@ export {
   sessionScopedPath,
   setJsonPath,
   setJsonPathInFile,
-  setOutputLineGuard,
-  setRawMode,
+  setTitle,
   setToolDescriptionMode,
   setToolResultRenderMode,
   simplifyToolDescription,
@@ -3747,9 +3992,7 @@ export {
   updateJsonObjectFile,
   validateAgainstSchema,
   withFileLock,
-  writeErr,
   writeJsonObjectFile,
-  writeOut,
   wstackGlobalRoot
 };
 //# sourceMappingURL=index.js.map