chainlesschain 0.162.60 → 0.162.65

package/src/lib/cost-budget.js

@@ -0,0 +1,109 @@
+/**
+ * cost-budget — a hard USD spend cap for unattended agent runs
+ * (Claude-Code `--max-budget-usd` parity).
+ *
+ * Where IterationBudget caps the number of agent-loop turns, CostBudget caps the
+ * estimated dollar cost: it accumulates the per-call cost (via llm-pricing) as
+ * token-usage events arrive and reports when the cap is reached, so the runner
+ * can stop BEFORE making another paid LLM call. Because a call's cost is only
+ * known after it returns, a run may overshoot by at most one call — it never
+ * starts a new turn once over budget.
+ *
+ * Local/free providers (ollama, …) and unpriced models cost $0 here, so a cap
+ * can never trigger for them; `shouldWarnInactive()` lets the caller surface a
+ * one-time "cap inactive" notice instead of silently doing nothing.
+ *
+ * Pure + dependency-light (only llm-pricing) so it is unit-testable without a
+ * real agent loop.
+ */
+
+import { estimateCost } from "./llm-pricing.js";
+
+const round = (n, dp = 6) => {
+  const f = Math.pow(10, dp);
+  return Math.round((Number(n) + Number.EPSILON) * f) / f;
+};
+
+/** Parse a `--max-budget-usd` value into a positive number, or null when unset. */
+export function parseBudgetUsd(value) {
+  if (value == null || value === "") return null;
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new Error(
+      `Invalid --max-budget-usd "${value}". Expected a positive number of US dollars.`,
+    );
+  }
+  return n;
+}
+
+export class CostBudget {
+  /**
+   * @param {object} opts
+   * @param {number|null} [opts.limitUsd] cap in USD; null/≤0 → disabled
+   * @param {object} [opts.table]         merged price table (mergePricing output)
+   */
+  constructor({ limitUsd = null, table = undefined } = {}) {
+    const lim = Number(limitUsd);
+    this.limitUsd = Number.isFinite(lim) && lim > 0 ? lim : null;
+    this.table = table;
+    this.spentUsd = 0;
+    this.priced = false; // priced ≥1 non-free usage record
+    this.sawUnpriced = false; // saw tokens we couldn't price
+    this.sawFree = false; // saw a free/local provider
+    this._warned = false;
+  }
+
+  enabled() {
+    return this.limitUsd != null;
+  }
+
+  /**
+   * Fold one token-usage record into the running spend.
+   * @returns {object} the estimateCost() result for this record
+   */
+  add({ provider, model, usage } = {}) {
+    const est = estimateCost({
+      provider,
+      model,
+      inputTokens: usage?.input_tokens || 0,
+      outputTokens: usage?.output_tokens || 0,
+      table: this.table,
+    });
+    const tokens = (usage?.input_tokens || 0) + (usage?.output_tokens || 0);
+    if (est.free) {
+      this.sawFree = true;
+    } else if (est.matched) {
+      this.spentUsd = round(this.spentUsd + est.totalCost);
+      this.priced = true;
+    } else if (tokens > 0) {
+      this.sawUnpriced = true;
+    }
+    return est;
+  }
+
+  /** True once the running spend has reached/passed the cap. */
+  exceeded() {
+    return this.limitUsd != null && this.spentUsd >= this.limitUsd;
+  }
+
+  /** USD left under the cap (Infinity when disabled). */
+  remaining() {
+    return this.limitUsd == null
+      ? Infinity
+      : Math.max(0, round(this.limitUsd - this.spentUsd));
+  }
+
+  /**
+   * True the FIRST time we can tell the cap can't bite — a cap was set but every
+   * usage so far has been free/local or unpriced, so spend stays $0. Lets the
+   * caller print a one-time "cap inactive" warning instead of a silent no-op.
+   */
+  shouldWarnInactive() {
+    if (!this.enabled() || this._warned || this.priced) return false;
+    if (this.sawUnpriced || this.sawFree) {
+      this._warned = true;
+      return true;
+    }
+    return false;
+  }
+}

package/src/lib/ide-context.js

@@ -278,6 +278,13 @@ export function hasIdeOpenDiff(mcp) {
  * Run one blocking openDiff review in the connected IDE. Returns
  *   { outcome:"accepted", finalText|null }  — the IDE wrote the file itself
  *   { outcome:"rejected" }                  — nothing was written
+ *   { outcome:"changes-requested", comments, reviewedText }
+ *                                           — the user annotated the diff with
+ *                                             revision notes instead of
+ *                                             accepting/rejecting; nothing was
+ *                                             written and the caller should
+ *                                             feed `comments` back to the agent
+ *                                             so it revises and re-proposes.
  *   null                                    — IDE unavailable / transport
  *                                             error / malformed reply → the
  *                                             caller falls back to its normal
@@ -309,10 +316,53 @@ export async function requestIdeDiffApproval(mcp, req = {}) {
       finalText: typeof data.finalText === "string" ? data.finalText : null,
     };
   }
+  if (data?.outcome === "changes-requested") {
+    return {
+      outcome: "changes-requested",
+      comments: Array.isArray(data.comments) ? data.comments : [],
+      reviewedText:
+        typeof data.reviewedText === "string" ? data.reviewedText : null,
+    };
+  }
   if (data?.outcome === "rejected") return { outcome: "rejected" };
   return null; // anything else is not a verdict — fail safe to fallback
 }
 
+/**
+ * Render line-anchored review comments (from an openDiff "changes-requested"
+ * verdict) into a compact feedback block the agent can act on. Each comment is
+ * `{ line?, endLine?, lineText?, note }` with 0-based editor lines. Returns
+ * null when there is no actionable note. Pure — safe to unit-test.
+ */
+export function formatReviewComments(comments, { path: filePath } = {}) {
+  if (!Array.isArray(comments) || comments.length === 0) return null;
+  const lines = comments
+    .map((c) => {
+      if (!c || typeof c.note !== "string" || c.note.trim().length === 0) {
+        return null;
+      }
+      const start = Number.isInteger(c.line) ? c.line + 1 : null; // 0→1-based
+      const end = Number.isInteger(c.endLine) ? c.endLine + 1 : start;
+      const where =
+        start != null
+          ? end != null && end !== start
+            ? `lines ${start}-${end}`
+            : `line ${start}`
+          : "(general)";
+      const anchor =
+        typeof c.lineText === "string" && c.lineText.trim().length > 0
+          ? `  ⟪${c.lineText.trim().slice(0, 120)}⟫`
+          : "";
+      return `  • ${where}: ${c.note.trim()}${anchor}`;
+    })
+    .filter(Boolean);
+  if (lines.length === 0) return null;
+  const header = filePath
+    ? `Review comments on ${filePath}:`
+    : "Review comments:";
+  return `${header}\n${lines.join("\n")}`;
+}
+
 // ─── Explicit @selection / @diagnostics at-mentions (Claude-Code parity) ────
 //
 // The ambient `<ide-context>` block above shares the selection on every turn.

package/src/lib/image-input.js

@@ -115,8 +115,14 @@ export function imageUrlBlockToAnthropic(block) {
   };
 }
 
-/** Default vision model (Volcengine Ark Doubao-Seed-1.6 Vision) when none configured. */
-export const DEFAULT_VISION_MODEL = "doubao-seed-1-6-vision-250815";
+/**
+ * Default vision model when none is configured — Volcengine Ark
+ * Doubao-Seed-2.0-lite (id `doubao-seed-2-0-lite-260215`, dated YYMMDD =
+ * 2026-02-15), a natively multimodal model (text/image/video; 2.0 has no
+ * separate "-vision-" SKU). Override via --vision-model or config.llm.visionModel
+ * to pin a different snapshot.
+ */
+export const DEFAULT_VISION_MODEL = "doubao-seed-2-0-lite-260215";
 
 /**
  * Resolve the effective LLM config for a run. When an image is attached, default

package/src/lib/llm-pricing.js

@@ -58,6 +58,12 @@ export const PRICE_TABLE = Object.freeze({
   ],
   // Volcengine Doubao — rough USD conversion of public RMB list pricing.
   volcengine: [
+    // Doubao Seed 2.0 family (2026, e.g. doubao-seed-2-0-lite-260215) is
+    // natively multimodal. Rates ≈ official CNY ÷ ~7.2 (lite ≤32k is 0.6/3.6
+    // CNY → $0.08/$0.50); the generic "seed" rate below underprices 2.0 output.
+    { match: "seed-2-0-pro", in: 0.5, out: 2.5 },
+    { match: "seed-2-0-lite", in: 0.08, out: 0.5 },
+    { match: "seed-2-0-mini", in: 0.03, out: 0.3 },
     { match: "seed-1-6", in: 0.11, out: 0.28 },
     { match: "seed", in: 0.11, out: 0.28 },
     { match: "pro", in: 0.11, out: 0.28 },

package/src/lib/personal-data-hub-wiring.js

@@ -57,6 +57,8 @@ const {
   ZhihuAdapter,
   BossZhipinAdapter,
   CsdnAdapter,
+  DongchediAdapter,
+  TianyanchaAdapter,
   DouyinAdapter,
   XiaohongshuAdapter,
   ToutiaoAdapter,
@@ -74,12 +76,18 @@ const {
   KugouMusicAdapter,
   IqiyiVideoAdapter,
   TencentVideoAdapter,
+  XiguaVideoAdapter,
   WeReadAdapter,
   WpsDocAdapter,
   TencentDocsAdapter,
   BaiduNetdiskAdapter,
+  CamScannerDocAdapter,
+  IXiamenAdapter,
+  MeiyouAdapter,
+  TaxAdapter,
   DingTalkPcAdapter,
   FeishuPcAdapter,
+  WeWorkPcAdapter,
   BaiduMapAdapter,
   TencentMapAdapter,
   JdAdapter,
@@ -529,6 +537,8 @@ async function initHub() {
     ZhihuAdapter,
     BossZhipinAdapter,
     CsdnAdapter,
+    DongchediAdapter,
+    TianyanchaAdapter,
     DouyinAdapter,
     XiaohongshuAdapter,
     ToutiaoAdapter,
@@ -546,12 +556,18 @@ async function initHub() {
     KugouMusicAdapter,
     IqiyiVideoAdapter,
     TencentVideoAdapter,
+    XiguaVideoAdapter,
     WeReadAdapter,
     WpsDocAdapter,
     TencentDocsAdapter,
     BaiduNetdiskAdapter,
+    CamScannerDocAdapter,
+    IXiamenAdapter,
+    MeiyouAdapter,
+    TaxAdapter,
     DingTalkPcAdapter,
     FeishuPcAdapter,
+    WeWorkPcAdapter,
     BaiduMapAdapter,
     TencentMapAdapter,
     JdAdapter,

package/src/lib/terminal-setup.js

@@ -0,0 +1,209 @@
+/**
+ * terminal-setup — make Shift+Enter insert a newline in the agent REPL
+ * (Claude-Code `/terminal-setup` parity).
+ *
+ * cc's REPL is readline-based, so a bare Enter always submits. Multiline input
+ * is reached by ending a line with a continuation backslash (see
+ * repl-multiline.js). This module configures the terminal so that pressing
+ * Shift+Enter emits the byte sequence `<space>\<CR>` — which cc's
+ * backslash-continuation turns into a soft newline — giving the familiar
+ * "Shift+Enter = newline, Enter = send" editing without any REPL raw-mode hacks.
+ *
+ * Everything here is pure (detection + keybindings JSON shaping); the command
+ * (commands/terminal-setup.js) does the file I/O.
+ */
+
+import path from "node:path";
+import os from "node:os";
+
+/**
+ * The bytes Shift+Enter should send: space + backslash + carriage return. The
+ * leading space makes the trailing backslash satisfy repl-multiline's
+ * whitespace-gated continuation rule (so it is never mistaken for a Windows
+ * path), and the backslash is stripped back out when the line is joined.
+ */
+export const SHIFT_ENTER_SEQUENCE = " \\\r";
+
+/** Identify the host terminal from environment variables. */
+export function detectTerminal(env = process.env) {
+  const tp = String(env.TERM_PROGRAM || "").toLowerCase();
+  if (tp === "vscode" || env.VSCODE_PID || env.VSCODE_INJECTION) {
+    return { id: "vscode", name: "VS Code integrated terminal" };
+  }
+  if (tp === "iterm.app") return { id: "iterm2", name: "iTerm2" };
+  if (tp === "apple_terminal")
+    return { id: "apple-terminal", name: "Apple Terminal" };
+  if (tp === "wezterm") return { id: "wezterm", name: "WezTerm" };
+  if (env.WT_SESSION)
+    return { id: "windows-terminal", name: "Windows Terminal" };
+  return {
+    id: "unknown",
+    name: env.TERM_PROGRAM || env.TERM || "your terminal",
+  };
+}
+
+/** The VS Code keybinding that sends the Shift+Enter sequence in the terminal. */
+export function vscodeKeybinding() {
+  return {
+    key: "shift+enter",
+    command: "workbench.action.terminal.sendSequence",
+    when: "terminalFocus",
+    args: { text: SHIFT_ENTER_SEQUENCE },
+  };
+}
+
+/** Per-OS path to VS Code's user keybindings.json. */
+export function vscodeKeybindingsPath(
+  platform = process.platform,
+  env = process.env,
+) {
+  const home = os.homedir();
+  if (platform === "win32") {
+    const appData = env.APPDATA || path.join(home, "AppData", "Roaming");
+    return path.join(appData, "Code", "User", "keybindings.json");
+  }
+  if (platform === "darwin") {
+    return path.join(
+      home,
+      "Library",
+      "Application Support",
+      "Code",
+      "User",
+      "keybindings.json",
+    );
+  }
+  return path.join(home, ".config", "Code", "User", "keybindings.json");
+}
+
+/**
+ * Strip JSONC (line + block comments, trailing commas) so a keybindings.json
+ * with comments can be parsed. Best-effort and string-aware enough for the
+ * common case; callers must tolerate a null parse.
+ */
+export function stripJsonc(text) {
+  let out = "";
+  const s = String(text || "");
+  let inStr = false;
+  let strCh = "";
+  let i = 0;
+  while (i < s.length) {
+    const c = s[i];
+    const n = s[i + 1];
+    if (inStr) {
+      out += c;
+      if (c === "\\") {
+        out += n ?? "";
+        i += 2;
+        continue;
+      }
+      if (c === strCh) inStr = false;
+      i += 1;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      inStr = true;
+      strCh = c;
+      out += c;
+      i += 1;
+      continue;
+    }
+    if (c === "/" && n === "/") {
+      while (i < s.length && s[i] !== "\n") i += 1;
+      continue;
+    }
+    if (c === "/" && n === "*") {
+      i += 2;
+      while (i < s.length && !(s[i] === "*" && s[i + 1] === "/")) i += 1;
+      i += 2;
+      continue;
+    }
+    out += c;
+    i += 1;
+  }
+  // Drop trailing commas before } or ].
+  return out.replace(/,(\s*[}\]])/g, "$1");
+}
+
+/** Parse a JSONC keybindings array → array, or null when it cannot be parsed. */
+export function parseKeybindings(text) {
+  const src = String(text || "").trim();
+  if (!src) return [];
+  try {
+    const v = JSON.parse(stripJsonc(src));
+    return Array.isArray(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+/** True when an equivalent keybinding (key+command+when) already exists. */
+export function hasKeybinding(arr, binding) {
+  return (Array.isArray(arr) ? arr : []).some(
+    (b) =>
+      b &&
+      b.key === binding.key &&
+      b.command === binding.command &&
+      (b.when || "") === (binding.when || ""),
+  );
+}
+
+/**
+ * Textually append a keybinding before the closing `]`, preserving the file's
+ * existing comments/formatting. Returns the new file text, or null when `text`
+ * is non-empty but not a JSON array (caller should not overwrite blindly).
+ */
+export function appendKeybindingText(text, binding) {
+  const bindingJson = JSON.stringify(binding, null, 2)
+    .split("\n")
+    .map((l) => "  " + l)
+    .join("\n")
+    .trimStart();
+  const src = String(text || "").trim();
+  if (!src || src === "[]") {
+    return `[\n  ${bindingJson}\n]\n`;
+  }
+  const close = src.lastIndexOf("]");
+  if (close === -1) return null; // not an array
+  const before = src.slice(0, close).replace(/\s*$/, "");
+  const sep = before.endsWith("[") ? "" : ",";
+  return `${before}${sep}\n  ${bindingJson}\n]\n`;
+}
+
+/** Manual instructions for terminals cc cannot auto-configure. */
+export function instructionsFor(id) {
+  const seq = "a space, then a backslash, then Enter";
+  const common = `Bind Shift+Enter to send ${seq} (cc turns a trailing "\\" into a newline).`;
+  switch (id) {
+    case "iterm2":
+      return [
+        common,
+        "iTerm2 → Settings → Profiles → Keys → Key Mappings → + :",
+        '  Shortcut: Shift+Return   Action: "Send Text"   Text:  \\  (then a literal Return)',
+      ];
+    case "apple-terminal":
+      return [
+        common,
+        "Terminal → Settings → Profiles → Keyboard → + :",
+        '  Key: Shift+Return   Action: send string  " \\015" (space, backslash, CR)',
+      ];
+    case "windows-terminal":
+      return [
+        common,
+        "Windows Terminal → Settings → Actions (settings.json) → add:",
+        '  { "command": { "action": "sendInput", "input": " \\\\\\r" }, "keys": "shift+enter" }',
+      ];
+    case "wezterm":
+      return [
+        common,
+        "WezTerm (~/.wezterm.lua) keys:",
+        '  { key="Enter", mods="SHIFT", action=wezterm.action.SendString(" \\\\\\r") }',
+      ];
+    default:
+      return [
+        common,
+        "Most terminals let you remap a key to send custom text/bytes — point",
+        "Shift+Enter at the 3 bytes: space (0x20), backslash (0x5C), CR (0x0D).",
+        "Or just type a trailing \\ yourself to continue onto the next line.",
+      ];
+  }
+}

package/src/repl/agent-repl.js

@@ -75,7 +75,10 @@ import {
   agentLoop as coreAgentLoop,
   formatToolArgs,
   killAllBackgroundShellTasks,
+  killBackgroundShellTask,
+  listBackgroundShellTasks,
 } from "../runtime/agent-core.js";
+import { formatBackgroundTasks } from "./tasks-status.js";
 import { expandFileRefs } from "../runtime/file-ref-expander.js";
 import { composeSystemPrompt } from "../runtime/system-prompt.js";
 import {
@@ -833,6 +836,8 @@ export async function startAgentRepl(options = {}) {
       "/statusline",
       "/sub-agents",
       "/task",
+      "/tasks",
+      "/terminal-setup",
       "/vim",
     ],
     getIdeOpenFiles: async () => {
@@ -1176,6 +1181,9 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/vim")}        Toggle vim-mode line editing (/vim [on|off]; Esc → NORMAL)`,
       );
+      logger.log(
+        `  ${chalk.cyan("/terminal-setup")} Bind Shift+Enter → newline (--apply for VS Code)`,
+      );
       logger.log(
         `  ${chalk.cyan("/statusline")} Context-usage line on/off (/statusline [on|off])`,
       );
@@ -1249,6 +1257,9 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/sub-agents")}  Show active/completed sub-agents`,
       );
+      logger.log(
+        `  ${chalk.cyan("/tasks")}      Show background shell tasks (kill <id> · kill-all)`,
+      );
       logger.log(
         `  ${chalk.cyan("/ide")}        IDE bridge status (connected editor, tools, or why not)`,
       );
@@ -1288,6 +1299,35 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/tasks` — user-facing view of the agent's background shell tasks
+    // (run_shell run_in_background). Must precede the `/task` handler below,
+    // which matches with startsWith("/task") and would otherwise swallow it.
+    if (trimmed === "/tasks" || trimmed.startsWith("/tasks ")) {
+      const rest = trimmed.slice("/tasks".length).trim();
+      if (rest === "kill-all") {
+        const n = killAllBackgroundShellTasks();
+        logger.log(chalk.dim(`Killed ${n} background shell task(s).`));
+      } else if (rest.startsWith("kill ")) {
+        const id = rest.slice("kill ".length).trim();
+        const ok = id ? killBackgroundShellTask(id) : false;
+        logger.log(
+          ok
+            ? chalk.dim(`Killed background shell task ${id}.`)
+            : chalk.dim(`No running background shell task with id "${id}".`),
+        );
+      } else if (rest === "kill") {
+        logger.log(chalk.dim("Usage: /tasks kill <id> · /tasks kill-all"));
+      } else {
+        logger.log(
+          "
+" + formatBackgroundTasks(listBackgroundShellTasks()) + "
+",
+        );
+      }
+      prompt();
+      return;
+    }
+
     if (trimmed === "/sub-agents" || trimmed === "/subagents") {
       try {
         const { SubAgentRegistry } =
@@ -1384,6 +1424,23 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    if (
+      trimmed === "/terminal-setup" ||
+      trimmed.startsWith("/terminal-setup ")
+    ) {
+      try {
+        const arg = trimmed.slice("/terminal-setup".length).trim();
+        const { runTerminalSetup } =
+          await import("../commands/terminal-setup.js");
+        const res = runTerminalSetup({ apply: arg === "--apply" });
+        for (const l of res.lines) logger.log(l);
+      } catch (err) {
+        logger.error(`/terminal-setup failed: ${err.message}`);
+      }
+      prompt();
+      return;
+    }
+
     if (trimmed === "/vim" || trimmed.startsWith("/vim ")) {
       const arg = trimmed.slice("/vim".length).trim().toLowerCase();
       const turnOn = arg === "on" || (arg === "" && !_vimEnabled);
@@ -2507,7 +2564,7 @@ export async function startAgentRepl(options = {}) {
       const roles = {
         mainProvider: provider,
         mainModel: _curModel || model,
-        visionModel: visionModel || "doubao-seed-1-6-vision-250815",
+        visionModel: visionModel || "doubao-seed-2-0-lite-260215",
         fallbackModels: _fallbackModels || [],
       };
       const { renderSessionCost } = await import("./session-cost.js");

package/src/repl/tasks-status.js

@@ -0,0 +1,82 @@
+/**
+ * Pure renderer for the `/tasks` REPL command — a user-facing view of the
+ * agent's background shell tasks (the ones it starts with
+ * run_shell { run_in_background: true }). The data comes from agent-core's
+ * listBackgroundShellTasks(); this module only formats it, so it stays
+ * deterministic and unit-testable (inject `now` for stable elapsed time).
+ *
+ * Background shells are otherwise only visible to the agent (via its
+ * check_shell tool) — this surfaces them to the human, the way Claude Code's
+ * background-tasks view does. Sub-agents live under a separate registry and
+ * are shown by `/sub-agents`.
+ */
+
+/** Coerce an ISO-string or epoch-ms timestamp to epoch ms, or null. */
+function toMs(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string") {
+    const t = Date.parse(v);
+    return Number.isFinite(t) ? t : null;
+  }
+  return null;
+}
+
+/** Human-friendly elapsed duration. */
+function fmtElapsed(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "?";
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m${s % 60}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h${m % 60}m`;
+}
+
+/** A short status badge for one task. */
+export function taskStatusLabel(t) {
+  switch (t?.status) {
+    case "running":
+      return "● running";
+    case "exited":
+      return `✓ exited${t.exitCode != null ? ` (${t.exitCode})` : ""}`;
+    case "failed":
+      return `✗ failed${t.exitCode != null ? ` (${t.exitCode})` : ""}`;
+    case "error":
+      return "✗ error";
+    default:
+      return t?.status || "?";
+  }
+}
+
+/**
+ * Render the background-shell task list as a plain-text block.
+ * @param {Array} tasks  from listBackgroundShellTasks()
+ * @param {object} opts  { now?: epoch-ms } — defaults to Date.now()
+ */
+export function formatBackgroundTasks(tasks, { now = Date.now() } = {}) {
+  const list = Array.isArray(tasks) ? tasks : [];
+  if (list.length === 0) {
+    return (
+      "No background shell tasks.\n" +
+      "  (The agent starts these with run_shell run_in_background:true; " +
+      "sub-agents are under /sub-agents.)"
+    );
+  }
+  const running = list.filter((t) => t?.status === "running").length;
+  const lines = [
+    `Background shell tasks (${list.length}, ${running} running):`,
+  ];
+  for (const t of list) {
+    const started = toMs(t.startedAt);
+    const ended = toMs(t.endedAt);
+    const elapsed =
+      started != null ? fmtElapsed((ended ?? now) - started) : "?";
+    const cmd = String(t.command || "")
+      .replace(/\s+/g, " ")
+      .trim();
+    const cmdShort = cmd.length > 70 ? cmd.slice(0, 70) + "…" : cmd;
+    lines.push(`  ${taskStatusLabel(t)}  ${t.id}  ${elapsed}  ${cmdShort}`);
+  }
+  lines.push("Manage: /tasks kill <id> · /tasks kill-all");
+  return lines.join("\n");
+}