chainlesschain 0.162.143 → 0.162.148

package/src/lib/settings-hooks.cjs

@@ -82,20 +82,66 @@ function readJson(file, onWarn) {
   }
 }
 
+function managedSettingsFile(env = process.env) {
+  if (env.CC_MANAGED_SETTINGS) return path.resolve(env.CC_MANAGED_SETTINGS);
+  if (process.platform === "win32") {
+    const base = env.ProgramData || env.PROGRAMDATA || "C:\\ProgramData";
+    return path.join(base, "ChainlessChain", "managed-settings.json");
+  }
+  return "/etc/chainlesschain/managed-settings.json";
+}
+
+function appendHookBlock(merged, data) {
+  const block =
+    data && data.hooks && typeof data.hooks === "object" ? data.hooks : null;
+  if (!block) return false;
+  let contributed = false;
+  for (const [event, groups] of Object.entries(block)) {
+    if (!Array.isArray(groups)) continue;
+    for (const g of groups) {
+      if (!g || typeof g !== "object" || !Array.isArray(g.hooks)) continue;
+      const cmds = g.hooks.filter(
+        (h) => h && h.type === "command" && h.command,
+      );
+      if (cmds.length === 0) continue;
+      if (!merged[event]) merged[event] = [];
+      merged[event].push({ matcher: g.matcher ?? null, hooks: cmds });
+      contributed = true;
+    }
+  }
+  return contributed;
+}
+
 /**
  * Load + concatenate the `hooks` blocks across the hierarchy.
  * @returns {{ hooks: Record<string, Array<{matcher:string|null, hooks:Array<{type,command,timeout}>}>>, files:string[] }}
  */
-function loadHooks({ cwd = process.cwd(), settingsFile, onWarn } = {}) {
+function loadHooks({
+  cwd = process.cwd(),
+  settingsFile,
+  onWarn,
+  env = process.env,
+} = {}) {
   const merged = {};
   const files = [];
-  // Safe-mode kill switch (`cc agent --safe-mode` sets CC_SETTINGS_HOOKS=0):
-  // run with NO settings hooks so a broken hook can be diagnosed.
-  if (process.env.CC_SETTINGS_HOOKS === "0") {
-    return { hooks: merged, files };
+  const managedFile = managedSettingsFile(env);
+  let managed = null;
+  if (_deps.fs.existsSync(managedFile)) {
+    managed = readJson(managedFile, onWarn);
+    if (!managed) {
+      const error = new Error(
+        `managed settings are unreadable or malformed: ${managedFile}`,
+      );
+      error.code = "CC_MANAGED_SETTINGS_INVALID";
+      throw error;
+    }
   }
+  // Safe-mode kill switch (`cc agent --safe-mode` sets CC_SETTINGS_HOOKS=0):
+  // user/project hooks are disabled, but administrator hooks remain active.
+  const managedOnly = managed?.allowManagedHooksOnly === true;
+  const skipUnmanaged = env.CC_SETTINGS_HOOKS === "0" || managedOnly;
   const seenPaths = new Set();
-  for (const file of settingsFiles(cwd, settingsFile)) {
+  for (const file of skipUnmanaged ? [] : settingsFiles(cwd, settingsFile)) {
     // Dedup by RESOLVED path so the SAME physical file is never read twice — e.g.
     // `--settings .claude/settings.json` from the project root aliases the
     // auto-loaded cwd file, which would otherwise CONCATENATE its hook groups a
@@ -106,26 +152,16 @@ function loadHooks({ cwd = process.cwd(), settingsFile, onWarn } = {}) {
     if (seenPaths.has(resolved)) continue;
     seenPaths.add(resolved);
     const data = readJson(file, onWarn);
-    const block =
-      data && data.hooks && typeof data.hooks === "object" ? data.hooks : null;
-    if (!block) continue;
-    let contributed = false;
-    for (const [event, groups] of Object.entries(block)) {
-      if (!Array.isArray(groups)) continue;
-      for (const g of groups) {
-        if (!g || typeof g !== "object" || !Array.isArray(g.hooks)) continue;
-        const cmds = g.hooks.filter(
-          (h) => h && h.type === "command" && h.command,
-        );
-        if (cmds.length === 0) continue;
-        if (!merged[event]) merged[event] = [];
-        merged[event].push({ matcher: g.matcher ?? null, hooks: cmds });
-        contributed = true;
-      }
-    }
+    const contributed = appendHookBlock(merged, data);
     if (contributed) files.push(file);
   }
-  return { hooks: merged, files };
+  if (managed && appendHookBlock(merged, managed)) files.push(managedFile);
+  const result = { hooks: merged, files };
+  if (managed) {
+    result.managed = managed;
+    result.managedFile = managedFile;
+  }
+  return result;
 }
 
 /**
@@ -184,7 +220,8 @@ function collectHooks(hooksBlock, event, toolName) {
   for (const g of groups) {
     const fn = compileMatcher(g.matcher);
     if (fn(umbrella) || (raw && fn(raw))) {
-      for (const h of g.hooks) out.push({ command: h.command, timeout: h.timeout });
+      for (const h of g.hooks)
+        out.push({ command: h.command, timeout: h.timeout });
     }
   }
   return out;
@@ -265,6 +302,11 @@ function writeHookTrustStore(store) {
 function projectHookTrustNotice({ cwd = process.cwd(), settingsFile } = {}) {
   if (process.env.CC_HOOK_TRUST_NOTICE === "0") return null;
   if (process.env.CC_SETTINGS_HOOKS === "0") return null; // hooks won't run anyway
+  const managedFile = managedSettingsFile(process.env);
+  if (_deps.fs.existsSync(managedFile)) {
+    const managed = readJson(managedFile);
+    if (managed?.allowManagedHooksOnly === true) return null;
+  }
   const home = path.join(_deps.homedir(), ".claude", "settings.json");
   const explicit = settingsFile ? path.resolve(cwd, settingsFile) : null;
   const trusted = new Set([home, explicit].filter(Boolean));
@@ -328,6 +370,7 @@ module.exports = {
   compileMatcher,
   umbrellaFor,
   settingsFiles,
+  managedSettingsFile,
   HOOK_EVENTS,
   _deps,
 };

package/src/lib/settings-loader.cjs

@@ -88,6 +88,69 @@ function settingsPaths(cwd, explicitFile) {
   return list;
 }
 
+/** Organization-controlled settings file. This layer is always highest. */
+function managedSettingsPath(opts = {}) {
+  if (opts.managedSettingsFile) return path.resolve(opts.managedSettingsFile);
+  const env = opts.env || process.env;
+  if (env.CC_MANAGED_SETTINGS) return path.resolve(env.CC_MANAGED_SETTINGS);
+  if (process.platform === "win32") {
+    const base = env.ProgramData || env.PROGRAMDATA || "C:\\ProgramData";
+    return path.join(base, "ChainlessChain", "managed-settings.json");
+  }
+  return "/etc/chainlesschain/managed-settings.json";
+}
+
+function loadManagedSettings(opts = {}) {
+  const file = managedSettingsPath(opts);
+  if (!_deps.fs.existsSync(file)) return { file, settings: null };
+  const data = readSettingsFile(file, { onWarn: opts.onWarn });
+  if (!data) {
+    const error = new Error(
+      `managed settings are unreadable or malformed: ${file}`,
+    );
+    error.code = "CC_MANAGED_SETTINGS_INVALID";
+    throw error;
+  }
+  return { file, settings: data };
+}
+
+function emptyRules() {
+  return { allow: [], ask: [], deny: [] };
+}
+
+/** Apply the non-bypassable permission portion of managed settings. */
+function applyManagedPermissionPolicy(baseRules, managed, sources = {}) {
+  const policy = managed && typeof managed === "object" ? managed : {};
+  const rules = policy.allowManagedPermissionRulesOnly
+    ? emptyRules()
+    : {
+        allow: [...(baseRules?.allow || [])],
+        ask: [...(baseRules?.ask || [])],
+        deny: [...(baseRules?.deny || [])],
+      };
+  const perms =
+    policy.permissions && typeof policy.permissions === "object"
+      ? policy.permissions
+      : {};
+  for (const kind of KINDS) {
+    accrete(rules[kind], sources, perms[kind], "<managed>", kind);
+  }
+  return rules;
+}
+
+function assertManagedPermissionMode(mode, managed) {
+  if (
+    mode === "bypassPermissions" &&
+    (managed?.disableBypassPermissionsMode === true ||
+      managed?.disableBypassPermissionsMode === "disable")
+  ) {
+    throw new Error(
+      'permission mode "bypassPermissions" is disabled by managed settings',
+    );
+  }
+  return mode;
+}
+
 /** Parse a comma/space separated env override into a string[]. */
 function parseEnvList(value) {
   if (!value) return [];
@@ -116,7 +179,7 @@ function loadSettings(opts = {}) {
   const env = opts.env || process.env;
   const onWarn = opts.onWarn;
 
-  const rules = { allow: [], ask: [], deny: [] };
+  let rules = emptyRules();
   const sources = {};
   const files = [];
 
@@ -150,7 +213,27 @@ function loadSettings(opts = {}) {
   }
   if (envContributed) files.push("<env>");
 
-  return { rules, sources, files };
+  const managedLoaded = loadManagedSettings({
+    env,
+    managedSettingsFile: opts.managedSettingsFile,
+    onWarn,
+  });
+  if (managedLoaded.settings) {
+    rules = applyManagedPermissionPolicy(
+      rules,
+      managedLoaded.settings,
+      sources,
+    );
+    files.push(managedLoaded.file);
+  }
+
+  return {
+    rules,
+    sources,
+    files,
+    managed: managedLoaded.settings,
+    managedFile: managedLoaded.settings ? managedLoaded.file : null,
+  };
 }
 
 /** Look up the source file a matched `{ kind, rule }` came from. */
@@ -236,6 +319,24 @@ function loadSettingsConfig(opts = {}) {
     }
     if (contributed) files.push(file);
   }
+  const managed = loadManagedSettings(opts);
+  if (managed.settings) {
+    const data = managed.settings;
+    let contributed = false;
+    if (typeof data.model === "string" && data.model.trim()) {
+      model = data.model.trim();
+      contributed = true;
+    }
+    if (data.env && typeof data.env === "object" && !Array.isArray(data.env)) {
+      for (const [k, v] of Object.entries(data.env)) {
+        if (typeof v === "string") {
+          env[k] = v;
+          contributed = true;
+        }
+      }
+    }
+    if (contributed) files.push(managed.file);
+  }
   return { model, env, files };
 }
 
@@ -270,6 +371,14 @@ function readBooleanSetting(key, opts = {}) {
       value = node; // last (closest) layer wins
     }
   }
+  const managed = loadManagedSettings(opts);
+  if (managed.settings) {
+    let node = managed.settings;
+    for (const p of parts) {
+      node = node && typeof node === "object" ? node[p] : undefined;
+    }
+    if (typeof node === "boolean") value = node;
+  }
   return value;
 }
 
@@ -279,6 +388,10 @@ module.exports = {
   readSettingsFile,
   readBooleanSetting,
   settingsPaths,
+  managedSettingsPath,
+  loadManagedSettings,
+  applyManagedPermissionPolicy,
+  assertManagedPermissionMode,
   parseEnvList,
   ruleSource,
   addRule,

package/src/lib/task-list.js

@@ -0,0 +1,53 @@
+/**
+ * Background task listing utilities (ESM)
+ * Mirrors Claude Code /tasks behavior
+ * @module lib/task-list
+ */
+
+import { listBackgroundShellTasks } from "../runtime/agent-core.js";
+import { formatBackgroundTasks } from "../repl/tasks-status.js";
+import { logger } from "./logger.js";
+
+/**
+ * List all background tasks
+ * @param {Object} options List options
+ * @returns {Promise<Object>} task list result
+ */
+export async function listTasks(options = {}) {
+  const tasks = listBackgroundShellTasks();
+  const active = tasks.filter((t) => t.status === "running");
+  const completed = tasks.filter((t) => t.status !== "running");
+
+  if (tasks.length === 0) {
+    logger.info("No background tasks");
+    return { count: 0, active: 0, completed: 0, tasks: [] };
+  }
+
+  if (!options.quiet) {
+    logger.info(formatBackgroundTasks(tasks));
+  }
+
+  logger.info(
+    `  ${active.length} active, ${completed.length} completed (total: ${tasks.length})`,
+  );
+
+  return {
+    count: tasks.length,
+    active: active.length,
+    completed: completed.length,
+    tasks,
+    formatted: formatBackgroundTasks(tasks),
+  };
+}
+
+/**
+ * Get a specific task by ID
+ * @param {string} taskId
+ * @returns {Object|null}
+ */
+export function getTask(taskId) {
+  const tasks = listBackgroundShellTasks();
+  return tasks.find((t) => t.id === taskId) || null;
+}
+
+export default { listTasks, getTask };

package/src/repl/agent-repl.js

@@ -98,6 +98,7 @@ import { resolveSlashMacro } from "./slash-macro.js";
 import { expandMcpPrompt, renderMcpSurface } from "./mcp-prompt.js";
 import { newCostStore, addUsage } from "./session-cost.js";
 import { parseThinkCommand, parseEffortCommand } from "./think-command.js";
+import { parseBtwCommand, buildAsideBlock, applyAside } from "./btw-command.js";
 import { shouldStreamLive } from "./stream-decision.js";
 import { emptyTurnNotice } from "./empty-turn-notice.js";
 import { buildPermissionPrompt } from "./permission-prompt.js";
@@ -117,6 +118,7 @@ let _approvalGate = null;
 // confirmer for `ask` matches. Loaded once at REPL startup; null = no file.
 let _permissionRules = null;
 let _permissionConfirm = null;
+let _managedPermissionRulesOnly = false;
 // .claude/settings.json `hooks` block (decision-capable PreToolUse/PostToolUse).
 let _settingsHooks = null;
 // .claude/settings.json `respondToBashCommands` (Claude-Code 2.1.186): whether a
@@ -127,6 +129,7 @@ let _respondToBash;
 // the built-in verification allowlist through the shell-policy classifier (→
 // ApprovalGate confirm) instead of fast-pathing it. false = unset → off.
 let _classifyAllShell = false;
+let _sandbox = null;
 // Bounded log of tool calls the agent was BLOCKED from running this session
 // (shell-policy / ApprovalGate / settings rule / hook). Surfaced by
 // `/permissions denials` (Claude-Code 2.1.193 "recent denials"). In-memory only.
@@ -161,6 +164,12 @@ async function _fireNotification(message) {
  */
 async function _persistAlwaysAllow(tool, args) {
   try {
+    if (_managedPermissionRulesOnly) {
+      process.stderr.write(
+        "  always-allow is disabled by managed settings; ask your administrator to change the policy.\n",
+      );
+      return null;
+    }
     const rulesMod = await import("../lib/permission-rules.cjs");
     const { suggestAllowRule } = rulesMod.default || rulesMod;
     const rule = suggestAllowRule(tool || "run_shell", args || {});
@@ -194,6 +203,7 @@ async function executeTool(name, args) {
     permissionConfirm: _permissionConfirm,
     settingsHooks: _settingsHooks,
     classifyAllShell: _classifyAllShell,
+    sandbox: _sandbox,
   });
 }
 
@@ -371,6 +381,12 @@ export async function startAgentRepl(options = {}) {
   // (--thinking-budget) is the companion legacy-model budget_tokens override.
   let thinking = options.thinking || null;
   const thinkingBudget = options.thinkingBudget || null;
+  // `/btw` one-shot asides: queued notes that ride ONLY the next turn (sent to
+  // the model, then stripped so they never persist or carry forward).
+  // `_btwRestore` holds the user message + its pre-aside content so we can undo
+  // the injection after the turn (or as a backstop at the next submit on throw).
+  let pendingBtw = [];
+  let _btwRestore = null;
   // Current ApprovalGate session tier (strict|trusted|autopilot), mirrored here
   // so Shift+Tab can cycle it and `/permissions <tier>` can set it. Kept in sync
   // with _approvalGate.setSessionPolicy below.
@@ -402,6 +418,7 @@ export async function startAgentRepl(options = {}) {
   const additionalDirectories = Array.isArray(options.additionalDirectories)
     ? options.additionalDirectories
     : [];
+  _sandbox = options.sandbox || null;
   // Snapshot the work tree before each mutating tool (git engine) so the user
   // can `cc checkpoint restore` to just before any tool call.
   const autoCheckpoint = options.autoCheckpoint === true;
@@ -542,6 +559,8 @@ export async function startAgentRepl(options = {}) {
     const { loadSettings, readBooleanSetting } =
       await import("../lib/settings-loader.cjs");
     const loaded = loadSettings({ cwd: process.cwd() });
+    _managedPermissionRulesOnly =
+      loaded.managed?.allowManagedPermissionRulesOnly === true;
     // Claude-Code 2.1.186 respondToBashCommands (default OFF / opt-in when unset).
     _respondToBash = readBooleanSetting("respondToBashCommands", {
       cwd: process.cwd(),
@@ -578,8 +597,10 @@ export async function startAgentRepl(options = {}) {
       return ans === "y" || ans === "yes";
     };
   } catch (_err) {
+    if (_err?.code === "CC_MANAGED_SETTINGS_INVALID") throw _err;
     _permissionRules = null;
     _permissionConfirm = null;
+    _managedPermissionRulesOnly = false;
   }
 
   // Load .claude/settings.json `hooks` block (decision-capable PreToolUse/
@@ -1040,6 +1061,7 @@ export async function startAgentRepl(options = {}) {
       "/add-dir",
       "/agents",
       "/auto",
+      "/btw",
       "/cd",
       "/clear",
       "/compact",
@@ -1518,6 +1540,9 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/effort")}     Reasoning effort (/effort low|medium|high|xhigh; Anthropic)`,
       );
+      logger.log(
+        `  ${chalk.cyan("/btw")}        Queue a one-off aside for your next message (not saved to history)`,
+      );
       logger.log(`  ${chalk.cyan("/clear")}      Clear conversation`);
       logger.log(
         `  ${chalk.cyan("/vim")}        Toggle vim-mode line editing (/vim [on|off]; Esc → NORMAL)`,
@@ -2030,6 +2055,27 @@ export async function startAgentRepl(options = {}) {
       }
     }
 
+    // `/btw <note>` — queue a one-shot aside (Claude-Code parity). It rides the
+    // NEXT message to the model, then is stripped so it never bloats history.
+    {
+      const btw = parseBtwCommand(trimmed);
+      if (btw) {
+        if (btw.error) {
+          logger.info(btw.error);
+          prompt();
+          return;
+        }
+        pendingBtw.push(btw.text);
+        logger.info(
+          chalk.gray(
+            `Aside noted (${pendingBtw.length}) — rides your next message only, not saved to history.`,
+          ),
+        );
+        prompt();
+        return;
+      }
+    }
+
     if (trimmed === "/clear") {
       // Stash the conversation first so `/rewind clear` can restore it
       // (Claude-Code 2.1.191). A no-op /clear (nothing to stash) keeps any
@@ -3644,6 +3690,14 @@ export async function startAgentRepl(options = {}) {
       logger.verbose(`[hook] prompt rewritten by UserPromptSubmit hook`);
     }
 
+    // Backstop: if the previous turn's agentLoop threw before the success-path
+    // restore ran, undo its /btw aside now so it never leaks into this turn's
+    // history/model call. (Normal turns clear _btwRestore right after agentLoop.)
+    if (_btwRestore) {
+      _btwRestore.msg.content = _btwRestore.content;
+      _btwRestore = null;
+    }
+
     // Expand @path file references into context blocks (Claude-Code parity),
     // so `review @src/x.js` injects the file contents. Typo'd paths are warned
     // about and left as-is.
@@ -3746,8 +3800,10 @@ export async function startAgentRepl(options = {}) {
       }
     }
 
-    // Add user message
-    messages.push({ role: "user", content: _userMessageContent });
+    // Add user message (keep the object ref so a /btw aside can be injected for
+    // this turn's model call and then stripped before persistence).
+    const _userMsg = { role: "user", content: _userMessageContent };
+    messages.push(_userMsg);
 
     // Slot-filling: detect intent and fill missing parameters interactively
     try {
@@ -3856,6 +3912,23 @@ export async function startAgentRepl(options = {}) {
           }
         : {};
       if (_streamLive) process.stdout.write("\n");
+      // Inject any queued /btw asides into THIS turn's user message just before
+      // the model call. We remember the pre-aside content so it's restored right
+      // after agentLoop returns — the aside steers this answer but is never
+      // persisted (saveMessages/JSONL) or carried into later turns. Consumed on
+      // send (cleared now) so a thrown turn doesn't re-inject next time; the
+      // submit-start backstop restores if agentLoop throws before we get back.
+      if (pendingBtw.length > 0) {
+        const block = buildAsideBlock(pendingBtw);
+        if (block) {
+          _btwRestore = { msg: _userMsg, content: _userMsg.content };
+          _userMsg.content = applyAside(_userMsg.content, block);
+          logger.verbose(
+            `[btw] applied ${pendingBtw.length} aside(s) to this turn`,
+          );
+        }
+        pendingBtw = [];
+      }
       // Consume the one-shot resume-degeneracy flag for THIS turn so the role
       // merge fires exactly once (2.1.187 parity; see _sanitizeRolesNextTurn).
       const _mergeRolesThisTurn = _sanitizeRolesNextTurn;
@@ -3913,6 +3986,7 @@ export async function startAgentRepl(options = {}) {
         sessionId,
         cwd: process.cwd(),
         additionalDirectories,
+        sandbox: _sandbox,
         autoCheckpoint,
         checkpointSession: sessionId,
         checkpointMarks: _checkpointMarks,
@@ -3936,6 +4010,13 @@ export async function startAgentRepl(options = {}) {
       });
       _turnAbort = null;
 
+      // Strip the one-shot /btw aside now the model has seen it — so it is never
+      // persisted (DB saveMessages below) or carried into the next turn.
+      if (_btwRestore) {
+        _btwRestore.msg.content = _btwRestore.content;
+        _btwRestore = null;
+      }
+
       // Running spend for `/cost` (in-memory, works without persistence).
       if (usageEvents?.length) addUsage(_costStore, usageEvents);
 

package/src/repl/agents-status.js

@@ -65,7 +65,13 @@ export function parseAgentsCommand(line) {
   if (first === "help") return { action: "help" };
   if (first === "show") return { action: "show", name: tokens[1] || null };
   if (first === "new") {
-    return { action: "new", name: tokens[1] || null, description, tools, location };
+    return {
+      action: "new",
+      name: tokens[1] || null,
+      description,
+      tools,
+      location,
+    };
   }
   // A bare token is treated as a name to show.
   return { action: "show", name: first };
@@ -95,7 +101,7 @@ export function formatAgentsList(agents, profiles) {
   }
   lines.push(
     "",
-    "Manage: /agents show <name> · /agents new <name> · run via `cc agents run <name> \"<task>\"`",
+    'Manage: /agents show <name> · /agents new <name> · run via `cc agents run <name> "<task>"`',
   );
   return lines.join("\n");
 }

package/src/repl/btw-command.js

@@ -0,0 +1,56 @@
+/**
+ * Pure helpers for the REPL `/btw` aside (Claude-Code parity, one-shot variant).
+ *
+ * `/btw <note>` queues a side note that rides ONLY the next message: it is sent
+ * to the model for that one turn (so it can steer the answer) and then removed,
+ * so it is never persisted to the session history and never carried into later
+ * turns — i.e. context without bloat. vscode/readline-free → unit-testable; the
+ * REPL owns the queue + the inject/restore around the agentLoop call.
+ *
+ *   /btw I'm on Windows, use PowerShell   → queued, applied to the next turn only
+ *   /btw                                  → usage error (nothing queued)
+ */
+
+/** Parse a `/btw …` line. Returns { text } | { error } | null (not a /btw). */
+export function parseBtwCommand(trimmed) {
+  const t = String(trimmed == null ? "" : trimmed).trim();
+  if (t !== "/btw" && !t.startsWith("/btw ")) return null;
+  const text = t.slice("/btw".length).trim();
+  if (!text) {
+    return {
+      error:
+        "usage: /btw <note> — a one-off aside for your next message (sent to the model, not saved to history)",
+    };
+  }
+  return { text };
+}
+
+/**
+ * Render queued asides into a single tagged block, or null when there is
+ * nothing to add. The note tells the model this is ephemeral user guidance.
+ */
+export function buildAsideBlock(asides) {
+  const list = (Array.isArray(asides) ? asides : [])
+    .map((s) => String(s == null ? "" : s).trim())
+    .filter(Boolean);
+  if (!list.length) return null;
+  return (
+    '<aside note="one-off side note from the user — applies to THIS message only, not saved to history">\n' +
+    list.join("\n") +
+    "\n</aside>"
+  );
+}
+
+/**
+ * Append an aside block to a user message's content, preserving multimodal
+ * arrays (OpenAI-style content parts from --image turns). Returns the new
+ * content; a falsy block returns the content unchanged.
+ */
+export function applyAside(content, block) {
+  if (!block) return content;
+  if (Array.isArray(content)) {
+    return [...content, { type: "text", text: block }];
+  }
+  const s = content == null ? "" : String(content);
+  return s.length ? `${s}\n\n${block}` : block;
+}