@mu-crew/mu 3.13.3 → 4.0.0

package/dist/tui-ALPHYTA2.js

@@ -0,0 +1,1773 @@
+import { createRequire as __muCreateRequire } from "node:module"; const require = __muCreateRequire(import.meta.url);
+import {
+  formatElapsed,
+  loadDashboard,
+  matches
+} from "./chunk-AW2NONYU.js";
+import {
+  KNOWN_VERBS,
+  ambientIngest,
+  currentCallers,
+  parseOpKey,
+  syncEnabled
+} from "./chunk-GQNHIPJN.js";
+import {
+  DEFAULT_SUBSTATE,
+  TASK_STATUSES,
+  TASK_SUBSTATES,
+  activeMux,
+  attachShellLine,
+  formatPair,
+  getTask,
+  isTaskStatus,
+  openDb,
+  resolveMuxSessionWorkstreamName,
+  selectTaskNotes,
+  shellWord,
+  spawnerFromEnv,
+  tmuxAttachMode
+} from "./chunk-S424D5EP.js";
+import "./chunk-PZ5GOCWH.js";
+
+// src/cli/tui/index.ts
+import { render } from "ink";
+import { createElement } from "react";
+
+// src/cli/tui/app.tsx
+import { Box as Box4, Text as Text3, useApp, useInput as useInput2, useStdin, useStdout as useStdout2, useWindowSize as useWindowSize2 } from "ink";
+import { useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+
+// node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:\\u001B\\][^\\u0007\\u001B\\u009C]*${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+
+// node_modules/strip-ansi/index.js
+var regex = ansiRegex();
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  if (!string.includes("\x1B") && !string.includes("\x9B")) {
+    return string;
+  }
+  return string.replace(regex, "");
+}
+
+// node_modules/get-east-asian-width/lookup-data.js
+var ambiguousMinimalCodePoint = 161;
+var ambiguousMaximumCodePoint = 1114109;
+var ambiguousRanges = [161, 161, 164, 164, 167, 168, 170, 170, 173, 174, 176, 180, 182, 186, 188, 191, 198, 198, 208, 208, 215, 216, 222, 225, 230, 230, 232, 234, 236, 237, 240, 240, 242, 243, 247, 250, 252, 252, 254, 254, 257, 257, 273, 273, 275, 275, 283, 283, 294, 295, 299, 299, 305, 307, 312, 312, 319, 322, 324, 324, 328, 331, 333, 333, 338, 339, 358, 359, 363, 363, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 476, 593, 593, 609, 609, 708, 708, 711, 711, 713, 715, 717, 717, 720, 720, 728, 731, 733, 733, 735, 735, 768, 879, 913, 929, 931, 937, 945, 961, 963, 969, 1025, 1025, 1040, 1103, 1105, 1105, 8208, 8208, 8211, 8214, 8216, 8217, 8220, 8221, 8224, 8226, 8228, 8231, 8240, 8240, 8242, 8243, 8245, 8245, 8251, 8251, 8254, 8254, 8308, 8308, 8319, 8319, 8321, 8324, 8364, 8364, 8451, 8451, 8453, 8453, 8457, 8457, 8467, 8467, 8470, 8470, 8481, 8482, 8486, 8486, 8491, 8491, 8531, 8532, 8539, 8542, 8544, 8555, 8560, 8569, 8585, 8585, 8592, 8601, 8632, 8633, 8658, 8658, 8660, 8660, 8679, 8679, 8704, 8704, 8706, 8707, 8711, 8712, 8715, 8715, 8719, 8719, 8721, 8721, 8725, 8725, 8730, 8730, 8733, 8736, 8739, 8739, 8741, 8741, 8743, 8748, 8750, 8750, 8756, 8759, 8764, 8765, 8776, 8776, 8780, 8780, 8786, 8786, 8800, 8801, 8804, 8807, 8810, 8811, 8814, 8815, 8834, 8835, 8838, 8839, 8853, 8853, 8857, 8857, 8869, 8869, 8895, 8895, 8978, 8978, 9312, 9449, 9451, 9547, 9552, 9587, 9600, 9615, 9618, 9621, 9632, 9633, 9635, 9641, 9650, 9651, 9654, 9655, 9660, 9661, 9664, 9665, 9670, 9672, 9675, 9675, 9678, 9681, 9698, 9701, 9711, 9711, 9733, 9734, 9737, 9737, 9742, 9743, 9756, 9756, 9758, 9758, 9792, 9792, 9794, 9794, 9824, 9825, 9827, 9829, 9831, 9834, 9836, 9837, 9839, 9839, 9886, 9887, 9919, 9919, 9926, 9933, 9935, 9939, 9941, 9953, 9955, 9955, 9960, 9961, 9963, 9969, 9972, 9972, 9974, 9977, 9979, 9980, 9982, 9983, 10045, 10045, 10102, 10111, 11094, 11097, 12872, 12879, 57344, 63743, 65024, 65039, 65533, 65533, 127232, 127242, 127248, 127277, 127280, 127337, 127344, 127373, 127375, 127376, 127387, 127404, 917760, 917999, 983040, 1048573, 1048576, 1114109];
+var fullwidthMinimalCodePoint = 12288;
+var fullwidthMaximumCodePoint = 65510;
+var fullwidthRanges = [12288, 12288, 65281, 65376, 65504, 65510];
+var wideMinimalCodePoint = 4352;
+var wideMaximumCodePoint = 262141;
+var wideRanges = [4352, 4447, 8986, 8987, 9001, 9002, 9193, 9196, 9200, 9200, 9203, 9203, 9725, 9726, 9748, 9749, 9776, 9783, 9800, 9811, 9855, 9855, 9866, 9871, 9875, 9875, 9889, 9889, 9898, 9899, 9917, 9918, 9924, 9925, 9934, 9934, 9940, 9940, 9962, 9962, 9970, 9971, 9973, 9973, 9978, 9978, 9981, 9981, 9989, 9989, 9994, 9995, 10024, 10024, 10060, 10060, 10062, 10062, 10067, 10069, 10071, 10071, 10133, 10135, 10160, 10160, 10175, 10175, 11035, 11036, 11088, 11088, 11093, 11093, 11904, 11929, 11931, 12019, 12032, 12245, 12272, 12287, 12289, 12350, 12353, 12438, 12441, 12543, 12549, 12591, 12593, 12686, 12688, 12773, 12783, 12830, 12832, 12871, 12880, 42124, 42128, 42182, 43360, 43388, 44032, 55203, 63744, 64255, 65040, 65049, 65072, 65106, 65108, 65126, 65128, 65131, 94176, 94180, 94192, 94198, 94208, 101594, 101631, 101664, 101760, 101874, 101888, 102801, 102816, 102866, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110888, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110952, 110960, 111355, 119552, 119638, 119648, 119670, 126980, 126980, 127183, 127183, 127374, 127374, 127377, 127386, 127406, 127406, 127488, 127490, 127504, 127547, 127552, 127560, 127568, 127569, 127584, 127589, 127744, 127776, 127789, 127797, 127799, 127868, 127870, 127891, 127904, 127946, 127951, 127955, 127968, 127984, 127988, 127988, 127992, 128062, 128064, 128064, 128066, 128252, 128255, 128317, 128331, 128334, 128336, 128359, 128378, 128378, 128405, 128406, 128420, 128420, 128507, 128591, 128640, 128709, 128716, 128716, 128720, 128722, 128725, 128729, 128732, 128735, 128747, 128748, 128756, 128764, 128986, 128986, 128992, 129003, 129008, 129008, 129292, 129338, 129340, 129349, 129351, 129535, 129648, 129660, 129664, 129734, 129736, 129736, 129740, 129757, 129759, 129771, 129775, 129786, 131072, 196605, 196608, 262141];
+
+// node_modules/get-east-asian-width/utilities.js
+var isInRange = (ranges, codePoint) => {
+  let low = 0;
+  let high = Math.floor(ranges.length / 2) - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const i = mid * 2;
+    if (codePoint < ranges[i]) {
+      high = mid - 1;
+    } else if (codePoint > ranges[i + 1]) {
+      low = mid + 1;
+    } else {
+      return true;
+    }
+  }
+  return false;
+};
+
+// node_modules/get-east-asian-width/lookup.js
+var commonCjkCodePoint = 19968;
+var [wideFastPathStart, wideFastPathEnd] = /* @__PURE__ */ findWideFastPathRange(wideRanges);
+function findWideFastPathRange(ranges) {
+  let fastPathStart = ranges[0];
+  let fastPathEnd = ranges[1];
+  for (let index = 0; index < ranges.length; index += 2) {
+    const start = ranges[index];
+    const end = ranges[index + 1];
+    if (commonCjkCodePoint >= start && commonCjkCodePoint <= end) {
+      return [start, end];
+    }
+    if (end - start > fastPathEnd - fastPathStart) {
+      fastPathStart = start;
+      fastPathEnd = end;
+    }
+  }
+  return [fastPathStart, fastPathEnd];
+}
+var isAmbiguous = (codePoint) => {
+  if (codePoint < ambiguousMinimalCodePoint || codePoint > ambiguousMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(ambiguousRanges, codePoint);
+};
+var isFullwidth = (codePoint) => {
+  if (codePoint < fullwidthMinimalCodePoint || codePoint > fullwidthMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(fullwidthRanges, codePoint);
+};
+var isWide = (codePoint) => {
+  if (codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd) {
+    return true;
+  }
+  if (codePoint < wideMinimalCodePoint || codePoint > wideMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(wideRanges, codePoint);
+};
+
+// node_modules/get-east-asian-width/index.js
+function validate(codePoint) {
+  if (!Number.isSafeInteger(codePoint)) {
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+  }
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+  validate(codePoint);
+  if (isFullwidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+
+// node_modules/string-width/index.js
+var segmenter = new Intl.Segmenter();
+var visibleCharacterRegex = new RegExp("[^\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Nonspacing_Mark}\\p{Enclosing_Mark}\\p{Surrogate}]", "v");
+var spacingMarkRegex = new RegExp("\\p{Spacing_Mark}", "v");
+var rgiEmojiRegex = new RegExp("^\\p{RGI_Emoji}$", "v");
+var unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
+var extendedPictographicRegex = new RegExp("\\p{Extended_Pictographic}", "gu");
+function isDoubleWidthNonRgiEmojiSequence(segment) {
+  if (segment.length > 50) {
+    return false;
+  }
+  if (unqualifiedKeycapRegex.test(segment)) {
+    return true;
+  }
+  if (segment.includes("\u200D")) {
+    const pictographics = segment.match(extendedPictographicRegex);
+    return pictographics !== null && pictographics.length >= 2;
+  }
+  return false;
+}
+function baseVisible(segment) {
+  const index = segment.search(visibleCharacterRegex);
+  return index === -1 ? void 0 : segment.slice(index);
+}
+function isHangulLeadingJamo(codePoint) {
+  return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388;
+}
+function isHangulVowelJamo(codePoint) {
+  return codePoint >= 4448 && codePoint <= 4519 || codePoint >= 55216 && codePoint <= 55238;
+}
+function isHangulTrailingJamo(codePoint) {
+  return codePoint >= 4520 && codePoint <= 4607 || codePoint >= 55243 && codePoint <= 55291;
+}
+function isHangulJamo(codePoint) {
+  return isHangulLeadingJamo(codePoint) || isHangulVowelJamo(codePoint) || isHangulTrailingJamo(codePoint);
+}
+function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
+  const codePoints = [];
+  for (const character of visibleSegment) {
+    if (!visibleCharacterRegex.test(character)) {
+      continue;
+    }
+    codePoints.push(character.codePointAt(0));
+  }
+  if (codePoints.length === 0) {
+    return void 0;
+  }
+  let width = 0;
+  for (let index = 0; index < codePoints.length; index++) {
+    const codePoint = codePoints[index];
+    if (!isHangulJamo(codePoint)) {
+      if (width === 0) {
+        return void 0;
+      }
+      for (let remaining = index; remaining < codePoints.length; remaining++) {
+        width += eastAsianWidth(codePoints[remaining], eastAsianWidthOptions);
+      }
+      return width;
+    }
+    if (isHangulLeadingJamo(codePoint) && isHangulVowelJamo(codePoints[index + 1])) {
+      width += 2;
+      index += isHangulTrailingJamo(codePoints[index + 2]) ? 2 : 1;
+      continue;
+    }
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+  }
+  return width;
+}
+function trailingWidth(visibleSegment, eastAsianWidthOptions) {
+  let extra = 0;
+  let first = true;
+  for (const character of visibleSegment) {
+    if (first) {
+      first = false;
+      continue;
+    }
+    if (spacingMarkRegex.test(character) || character >= "\uFF00" && character <= "\uFFEF") {
+      extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
+    }
+  }
+  return extra;
+}
+function stringWidth(input, options = {}) {
+  if (typeof input !== "string" || input.length === 0) {
+    return 0;
+  }
+  const {
+    ambiguousIsNarrow = true,
+    countAnsiEscapeCodes = false
+  } = options;
+  let string = input;
+  if (!countAnsiEscapeCodes && (string.includes("\x1B") || string.includes("\x9B"))) {
+    string = stripAnsi(string);
+  }
+  if (string.length === 0) {
+    return 0;
+  }
+  if (/^[\u0020-\u007E]*$/.test(string)) {
+    return string.length;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+  for (const { segment } of segmenter.segment(string)) {
+    const visibleSegment = baseVisible(segment);
+    if (visibleSegment === void 0) {
+      continue;
+    }
+    if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
+      width += 2;
+      continue;
+    }
+    const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
+    if (hangulWidth !== void 0) {
+      width += hangulWidth;
+      continue;
+    }
+    const codePoint = visibleSegment.codePointAt(0);
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+    width += trailingWidth(visibleSegment, eastAsianWidthOptions);
+  }
+  return width;
+}
+
+// src/cli/tui/commands.ts
+import { spawn } from "child_process";
+var message = (e) => e instanceof Error ? e.message : String(e);
+var insideClient = () => Boolean(process.env.TMUX);
+function backHint(backend) {
+  if (backend !== "tmux") return { short: "", text: "" };
+  switch (tmuxAttachMode()) {
+    case "switch":
+      return { short: "back: C-b L", text: "back: C-b L" };
+    case "nested":
+      return { short: "detach: C-b C-b d", text: "detach: C-b d (nested: C-b C-b d)" };
+    case "plain":
+      return { short: "detach: C-b d", text: "detach: C-b d (nested: C-b C-b d)" };
+  }
+}
+async function attachKeyHint() {
+  try {
+    const { short } = backHint((await activeMux()).name);
+    return short === "" ? "a attach" : `a attach (${short})`;
+  } catch {
+    return "a attach";
+  }
+}
+async function planAttach(t) {
+  try {
+    const mux = await activeMux();
+    const target = { session: `mu-${t.workstream}`, window: t.tab ?? t.name };
+    const inside = insideClient();
+    const steps = await mux.attachCommands({ ...target, inside });
+    const outside = await mux.attachCommands({ ...target, inside: false, outside: true });
+    const { text } = backHint(mux.name);
+    const notice2 = `attaching ${target.session}:${target.window}${text === "" ? "" : ` \xB7 ${text}`}`;
+    return { ok: true, steps, line: attachShellLine(outside), notice: notice2 };
+  } catch (e) {
+    return { ok: false, reason: message(e), line: null };
+  }
+}
+var spawnStep = (step) => new Promise((resolve) => {
+  let stderr = "";
+  const env = { ...process.env };
+  if (step.nested === true) delete env.TMUX;
+  const child = spawn(step.command, [...step.args], {
+    stdio: ["inherit", "inherit", "pipe"],
+    env
+  });
+  child.stderr.on("data", (d) => {
+    stderr = (stderr + d.toString()).slice(-400);
+  });
+  child.on("error", (e) => resolve({ code: null, error: e.message, stderr }));
+  child.on("close", (code) => resolve({ code, stderr }));
+});
+var wordsOf = (step) => [step.command, ...step.args].map(shellWord).join(" ");
+async function runAttach(steps, run) {
+  const warnings = [];
+  for (const step of steps) {
+    let r;
+    try {
+      r = await run(step);
+    } catch (e) {
+      r = { code: null, error: message(e), stderr: "" };
+    }
+    if (r.code === 0) continue;
+    const why = r.error ?? `exit ${r.code ?? "?"}${r.stderr.trim() === "" ? "" : `: ${r.stderr.trim()}`}`;
+    if (step.optional === true) {
+      warnings.push(`${step.reason ?? wordsOf(step)} (${why})`);
+      continue;
+    }
+    return { ok: false, reason: `${wordsOf(step)} failed (${why})`, warnings };
+  }
+  return { ok: true, warnings };
+}
+var YANK_MAX_BYTES = 1024;
+var CONTROL = /[\u0000-\u001f\u007f-\u009f]/;
+function yankSequence(command) {
+  if (CONTROL.test(command)) return { ok: false, why: "it has control characters" };
+  if (Buffer.byteLength(command) > YANK_MAX_BYTES) return { ok: false, why: "it is too long" };
+  return { ok: true, sequence: `\x1B]52;c;${Buffer.from(command).toString("base64")}\x07` };
+}
+function copyCommand(t, opts = {}) {
+  switch (t.kind) {
+    case "notes":
+      return `mu task show ${shellWord(t.id)} -w ${shellWord(t.workstream)}${opts.all === true ? " --all" : ""}`;
+    case "scrollback":
+      return opts.attachLine ?? `mu agent read ${shellWord(t.name)} -w ${shellWord(t.workstream)}`;
+    case "log":
+      return `mu log --all --since ${Math.max(0, t.item.seq - 1)} -n 1`;
+  }
+}
+
+// src/cli/tui/drill.tsx
+import { Box as Box2, Text as Text2, useInput, useStdout, useWindowSize } from "ink";
+import { useEffect, useMemo, useRef, useState } from "react";
+
+// src/cli/tui/frame.tsx
+import { Box, Text } from "ink";
+
+// src/cli/tui/text.ts
+var ESCAPES = /\u001b\[[0-?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)?|\u001b./g;
+var CONTROL2 = /[\u0000-\u001f\u007f-\u009f]/g;
+function clean(s) {
+  return s.replace(ESCAPES, "").replace(CONTROL2, " ");
+}
+var segmenter2 = new Intl.Segmenter();
+function cell(s, width) {
+  if (width <= 0) return "";
+  const text = clean(s);
+  const w = stringWidth(text);
+  if (w <= width) return text + " ".repeat(width - w);
+  let out = "";
+  let used = 0;
+  for (const { segment } of segmenter2.segment(text)) {
+    const sw = stringWidth(segment);
+    if (used + sw > width - 1) break;
+    out += segment;
+    used += sw;
+  }
+  return `${out}\u2026${" ".repeat(width - used - 1)}`;
+}
+function scrollTop(top, selected, count, height) {
+  const h = Math.max(1, height);
+  let next = top;
+  if (selected < next) next = selected;
+  else if (selected >= next + h) next = selected - h + 1;
+  return Math.max(0, Math.min(next, count - h));
+}
+var lineText = (line) => line.map((s) => s.text).join("");
+function fitLine(line, width) {
+  if (width <= 0) return [];
+  const runs = line.map((s) => ({ ...s, text: clean(s.text) }));
+  const total = stringWidth(runs.map((s) => s.text).join(""));
+  if (total <= width) return [...runs, { text: " ".repeat(width - total) }];
+  const out = [];
+  let used = 0;
+  for (const run of runs) {
+    let text = "";
+    for (const { segment } of segmenter2.segment(run.text)) {
+      const sw = stringWidth(segment);
+      if (used + sw > width - 1) {
+        out.push({ ...run, text: `${text}\u2026` });
+        return [...out, { text: " ".repeat(width - used - 1) }];
+      }
+      text += segment;
+      used += sw;
+    }
+    out.push({ ...run, text });
+  }
+  return out;
+}
+
+// src/cli/tui/theme.ts
+var STYLES = {
+  /** Plain text (titles in lists, prose). */
+  text: {},
+  /** Frame borders (rounded, gray). */
+  border: { color: "gray" },
+  /** A frame's title, the selected tab and workstream. */
+  title: { color: "cyan", bold: true },
+  /** Secondary text: subtitles, `+N more`, owners, times, hosts, hint, filter, next. */
+  muted: { dimColor: true },
+  /** A row's id or name. */
+  id: { bold: true },
+  /** Emphasis without colour: a drill's pinned notice (an attach failure). */
+  strong: { bold: true },
+  /** A log line's verb. */
+  verb: { color: "cyan" },
+  /** A drill's title line. */
+  heading: { color: "magenta", bold: true },
+  /** Task OPEN (ready). */
+  open: { color: "cyan" },
+  /** Task OPEN/parked and OPEN/triage: out of the ready set. */
+  parked: { color: "gray" },
+  /** Task IN_PROGRESS. */
+  progress: { color: "yellow" },
+  /** Task CLOSED/done. */
+  done: { color: "green" },
+  /** Task CLOSED as anything but done (wontfix, duplicate, superseded). */
+  undone: { color: "red" },
+  /** Agent busy. */
+  busy: { color: "cyan" },
+  /** Agent waiting on a permission dialog. */
+  permission: { color: "magenta" },
+  /** "all quiet". */
+  good: { color: "green" },
+  /** Needs a look: an attention item, a stalled tool, a sync warning. */
+  warn: { color: "yellow" },
+  /** Broken: a dead agent, an error. */
+  bad: { color: "red" }
+};
+var colorOn = () => process.env.NO_COLOR === void 0;
+function style(role = "text") {
+  const s = STYLES[role];
+  if (colorOn() || s.color === void 0) return s;
+  const { color: _, ...rest } = s;
+  return rest;
+}
+function statusRole(status, substate) {
+  if (status === "OPEN") return substate === "parked" || substate === "triage" ? "parked" : "open";
+  if (status === "IN_PROGRESS") return "progress";
+  if (status === "CLOSED") {
+    const dflt = isTaskStatus(status) ? DEFAULT_SUBSTATE[status] : "done";
+    return substate === "" || substate === dflt ? "done" : "undone";
+  }
+  return "text";
+}
+function agentStateRole(state) {
+  if (state === "busy") return "busy";
+  if (state === "needs_permission") return "permission";
+  return "muted";
+}
+
+// src/cli/tui/frame.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var FRAME_CHROME = 2;
+var FRAME_SIDES = 4;
+function borderParts(width, left, right, label) {
+  if (width < 2) return { head: "\u2500".repeat(Math.max(0, width)), shown: "", tail: "" };
+  const inner = width - 2;
+  const text = clean(label);
+  if (text === "") return { head: left + "\u2500".repeat(inner) + right, shown: "", tail: "" };
+  const room = Math.max(0, inner - 4);
+  const shown = stringWidth(text) <= room ? text : cell(text, room).trimEnd();
+  const fill = "\u2500".repeat(Math.max(1, inner - 3 - stringWidth(shown)));
+  return { head: `${left}\u2500 `, shown, tail: ` ${fill}${right}` };
+}
+function Segs({ line }) {
+  return /* @__PURE__ */ jsx(Fragment, { children: line.map((seg, i) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: runs of one line are positional
+    /* @__PURE__ */ jsx(Text, { ...style(seg.role), children: seg.text }, i)
+  )) });
+}
+function borderSegs(width, left, right, title, rest) {
+  const label = title !== "" && rest !== "" ? `${title} \xB7 ${rest}` : title || rest;
+  const { head, shown, tail } = borderParts(width, left, right, label);
+  const t = title === "" ? 0 : Math.min(shown.length, clean(title).length);
+  const sep = title !== "" && rest !== "" ? shown.slice(t, t + 3) : "";
+  const parts = [
+    { text: head, role: "border" },
+    { text: shown.slice(0, t), role: "title" },
+    { text: sep, role: "border" },
+    { text: shown.slice(t + sep.length), role: "muted" },
+    { text: tail, role: "border" }
+  ];
+  return parts.filter((p) => p.text !== "");
+}
+function Frame({ body, selected, ...spec }) {
+  if (spec.height < FRAME_CHROME || spec.width < FRAME_SIDES) return null;
+  const rows = Math.max(0, spec.height - FRAME_CHROME);
+  const room = Math.max(0, spec.width - FRAME_SIDES);
+  const lineOf = (b) => typeof b === "string" ? [{ text: b }] : b ?? [];
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: spec.width, height: spec.height, flexShrink: 0, children: [
+    /* @__PURE__ */ jsx(Text, { wrap: "truncate", children: /* @__PURE__ */ jsx(Segs, { line: borderSegs(spec.width, "\u256D", "\u256E", spec.title, spec.subtitle ?? "") }) }),
+    Array.from({ length: rows }, (_, i) => {
+      const fitted = fitLine(lineOf(body[i]), room);
+      return (
+        // biome-ignore lint/suspicious/noArrayIndexKey: fixed-height frame, rows are positional
+        /* @__PURE__ */ jsxs(Text, { wrap: "truncate", children: [
+          /* @__PURE__ */ jsx(Text, { ...style("border"), children: "\u2502 " }),
+          i === selected ? /* @__PURE__ */ jsx(Text, { inverse: true, children: fitted.map((s) => s.text).join("") }) : /* @__PURE__ */ jsx(Segs, { line: fitted }),
+          /* @__PURE__ */ jsx(Text, { ...style("border"), children: " \u2502" })
+        ] }, i)
+      );
+    }),
+    /* @__PURE__ */ jsx(Text, { wrap: "truncate", children: /* @__PURE__ */ jsx(Segs, { line: borderSegs(spec.width, "\u2570", "\u256F", "", spec.bottom ?? "") }) })
+  ] });
+}
+
+// src/cli/tui/nav.ts
+function navKey(input, key, page, space = false) {
+  const full = Math.max(1, page);
+  const half = Math.max(1, Math.floor(full / 2));
+  if (key.ctrl && input === "d") return { by: half };
+  if (key.ctrl && input === "u") return { by: -half };
+  if (key.ctrl || key.meta) return null;
+  if (key.downArrow || input === "j") return { by: 1 };
+  if (key.upArrow || input === "k") return { by: -1 };
+  if (key.pageDown || space && input === " ") return { by: full };
+  if (key.pageUp) return { by: -full };
+  if (input === "g" || key.home) return { to: "top" };
+  if (input === "G" || key.end) return { to: "bottom" };
+  return null;
+}
+var NAV_HINT = "j/k ^d/^u g/G";
+
+// src/cli/tui/drill.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var SCROLLBACK_LINES = 2e3;
+var END = Number.MAX_SAFE_INTEGER;
+var segmenter3 = new Intl.Segmenter();
+function wrap(text, width) {
+  const max = Math.max(1, width);
+  const out = [];
+  for (const raw of text.split(/\r\n|\n|\r/)) {
+    let cur = "";
+    let curW = 0;
+    let breakAt = -1;
+    let broke = false;
+    for (const { segment } of segmenter3.segment(clean(raw.replace(/\t/g, "    ")))) {
+      const sw = stringWidth(segment);
+      if (curW + sw > max) {
+        if (segment === " ") {
+          out.push(cur.trimEnd());
+          cur = "";
+          curW = 0;
+          breakAt = -1;
+          broke = true;
+          continue;
+        }
+        if (breakAt > 0) {
+          out.push(cur.slice(0, breakAt).trimEnd());
+          cur = cur.slice(breakAt);
+        } else {
+          if (cur !== "") out.push(cur);
+          cur = "";
+        }
+        curW = stringWidth(cur);
+        breakAt = -1;
+        broke = true;
+      }
+      if (broke && cur === "" && segment === " ") continue;
+      cur += segment;
+      curW += sw;
+      if (segment === " " && cur.trim() !== "") breakAt = cur.length;
+    }
+    out.push(cur.trimEnd());
+  }
+  return out;
+}
+var clampTop = (top, count, height) => Math.max(0, Math.min(top, count - Math.max(1, height)));
+function notesText(sel) {
+  return sel.notes.map(
+    (n) => `#${n.n}  ${n.kind}${sel.pinned.includes(n.n) ? " *" : ""}  ${n.author ?? "-"}  ${n.createdAt}
+${n.content}
+`
+  ).join("\n");
+}
+function titleOf(t) {
+  switch (t.kind) {
+    case "notes":
+      return `Notes  ${t.workstream}/${t.id}  ${t.title}`;
+    case "scrollback":
+      return `Scrollback  ${t.workstream}/${t.name}  ${t.paneId}  (last ${SCROLLBACK_LINES} lines)`;
+    case "log":
+      return `Log  #${t.item.seq}`;
+  }
+}
+function logText(t) {
+  const i = t.item;
+  return [
+    t.item.rendered,
+    "",
+    `seq: ${i.seq}`,
+    `time: ${i.created_at}`,
+    `scope: ${t.item.scope ?? "-"}`,
+    `actor: ${i.actor}`,
+    `intent: ${i.intent ?? "-"}`,
+    `op: ${i.op}`,
+    `entity: ${i.entity}`,
+    `key: ${i.key === "" ? "-" : i.key}`,
+    `payload: ${i.payload}`,
+    ...i.cut !== void 0 && i.cut > 0 ? [`(${i.cut} characters cut from this item)`] : []
+  ].join("\n");
+}
+function taskLine(t) {
+  if (t === void 0) return "task: gone";
+  return `${formatPair(t)}  ${t.ownerName === null ? "unowned" : `@${t.ownerName}`}  ${t.title}`;
+}
+function useYank() {
+  const { stdout } = useStdout();
+  return async (target, all = false) => {
+    const plan = target.kind === "scrollback" ? await planAttach(target) : null;
+    const command = copyCommand(target, { all, attachLine: plan?.line ?? null });
+    const y = yankSequence(command);
+    const why = plan !== null && !plan.ok ? `  (attach unavailable: ${plan.reason})` : "";
+    if (!y.ok) return `not copied (${y.why}): ${command}${why}`;
+    stdout.write(y.sequence);
+    return `copied: ${command}${why}`;
+  };
+}
+function Drill({
+  target,
+  runtime,
+  notice: notice2,
+  strip = null,
+  busy,
+  onClose,
+  onAttach,
+  nonce = 0,
+  slowNonce = 0
+}) {
+  const { columns, rows } = useWindowSize();
+  const yank = useYank();
+  const [all, setAll] = useState(false);
+  const [reload, setReload] = useState(0);
+  const [load, setLoad] = useState({ state: "loading" });
+  const [flash, setFlash] = useState(null);
+  const [top, setTop] = useState(target.kind === "scrollback" ? END : 0);
+  const topSeen = useRef(0);
+  const entityAll = useRef(false);
+  const tick = target.kind === "scrollback" ? slowNonce : nonce;
+  const entity = useRef(null);
+  useEffect(() => {
+    let live = true;
+    if (entity.current !== target || all !== entityAll.current) {
+      entity.current = target;
+      entityAll.current = all;
+      setLoad({ state: "loading" });
+    }
+    const done = (l) => {
+      if (live)
+        setLoad((prev) => JSON.stringify(prev) === JSON.stringify(l) ? prev : l);
+    };
+    try {
+      if (target.kind === "notes") {
+        const sel = runtime.notes(target.workstream, target.id, all);
+        done({
+          state: "ready",
+          text: sel.notes.length === 0 ? "(no notes)" : notesText(sel),
+          notices: sel.more > 0 ? [`${sel.more} of ${sel.total} notes not shown: A shows them all (oldest first)`] : [],
+          header: taskLine(runtime.task(target.workstream, target.id))
+        });
+      } else if (target.kind === "log") {
+        const { workstream, local } = parseOpKey(target.item.key === "" ? null : target.item.key);
+        const ctx = workstream !== void 0 && local !== void 0 && local !== "" ? `
+
+task now: ${taskLine(runtime.task(workstream, local))}` : "";
+        done({ state: "ready", text: `${logText(target)}${ctx}`, notices: [] });
+      } else {
+        void (async () => {
+          try {
+            const mux = await activeMux();
+            const text = await mux.capture(target.paneId, { lines: SCROLLBACK_LINES });
+            done({ state: "ready", text: text.replace(/\s+$/, ""), notices: [] });
+          } catch (e) {
+            done({ state: "error", message: e instanceof Error ? e.message : String(e) });
+          }
+        })();
+      }
+    } catch (e) {
+      done({ state: "error", message: e instanceof Error ? e.message : String(e) });
+    }
+    return () => {
+      live = false;
+    };
+  }, [target, runtime, all, reload, tick]);
+  const lines = useMemo(() => {
+    const above = [...notice2, ...flash === null ? [] : [flash]];
+    const ready = load.state === "ready" ? load : null;
+    const head = [
+      ...ready?.header !== void 0 ? [ready.header] : [],
+      ...ready?.notices ?? [],
+      ...above
+    ].flatMap((l) => wrap(l, columns));
+    const body = load.state === "loading" ? ["loading\u2026"] : load.state === "error" ? wrap(`error: ${load.message}`, columns) : wrap(load.text, columns);
+    return { head, body };
+  }, [load, notice2, flash, columns]);
+  const showStrip = strip !== null && rows >= 4;
+  const room = Math.max(0, rows - 1 - (rows >= 3 ? 1 : 0) - (showStrip ? 1 : 0));
+  const pinned = lines.head.slice(0, Math.floor(room / 2));
+  const height = room - pinned.length;
+  const first = clampTop(top, lines.body.length, height);
+  topSeen.current = first;
+  const hint = target.kind === "notes" ? `${NAV_HINT} scroll  A all notes  r reload  y copy cmd  Esc back` : target.kind === "scrollback" ? `${NAV_HINT} scroll  r reload  a attach  y copy cmd  Esc back` : `${NAV_HINT} scroll  y copy cmd  Esc back`;
+  useInput((input, key) => {
+    if (busy.current) return;
+    setFlash(null);
+    const at = topSeen.current;
+    if (key.escape || input === "q") return onClose();
+    const nav = navKey(input, key, height, true);
+    const end = Math.max(0, lines.body.length - Math.max(1, height));
+    if (nav !== null)
+      setTop(
+        "by" in nav ? at + nav.by >= end ? END : Math.max(0, at + nav.by) : nav.to === "top" ? 0 : END
+      );
+    else if (input === "r") setReload((n) => n + 1);
+    else if (input === "A" && target.kind === "notes") setAll((a) => !a);
+    else if (input === "a" && target.kind === "scrollback") onAttach(target);
+    else if (input === "y") void yank(target, all).then(setFlash);
+  });
+  const visible = lines.body.slice(first, first + height);
+  const where = lines.body.length === 0 ? "" : `${first + 1}-${Math.min(lines.body.length, first + height)}/${lines.body.length}  `;
+  return (
+    // Exactly `rows` lines: a short body is followed by the spacer, so the hint stays on the last row.
+    /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", height: rows, children: [
+      /* @__PURE__ */ jsx2(Text2, { wrap: "truncate", ...style("heading"), children: cell(titleOf(target), columns) }),
+      showStrip ? /* @__PURE__ */ jsx2(Text2, { wrap: "truncate", children: /* @__PURE__ */ jsx2(Segs, { line: fitLine(strip, columns) }) }) : null,
+      pinned.map((l, i) => (
+        // biome-ignore lint/suspicious/noArrayIndexKey: lines have no identity; the index IS the position
+        /* @__PURE__ */ jsx2(Text2, { wrap: "truncate", ...style("strong"), children: cell(l, columns) }, `p${i}`)
+      )),
+      visible.map((l, i) => (
+        // biome-ignore lint/suspicious/noArrayIndexKey: lines have no identity; the index IS the position
+        /* @__PURE__ */ jsx2(Text2, { wrap: "truncate", ...style(load.state === "error" ? "bad" : "text"), children: cell(l, columns) }, first + i)
+      )),
+      /* @__PURE__ */ jsx2(Box2, { flexGrow: 1 }),
+      rows >= 3 ? /* @__PURE__ */ jsx2(Text2, { wrap: "truncate", ...style("muted"), children: cell(`${where}${hint}`, columns) }) : null
+    ] })
+  );
+}
+
+// src/cli/tui/overview.tsx
+import { Box as Box3 } from "ink";
+
+// src/cli/tui/grid.ts
+var COLUMN_GAP = 1;
+function columnCount(cols) {
+  if (cols >= 180) return 3;
+  if (cols >= 120) return 2;
+  return 1;
+}
+function gridWidths(total, n) {
+  if (n <= 0) return [];
+  const usable = Math.max(n, total - COLUMN_GAP * (n - 1));
+  const base = Math.floor(usable / n);
+  const extra = usable - base * n;
+  return Array.from({ length: n }, (_, i) => base + (i < extra ? 1 : 0));
+}
+var PLACEMENT = {
+  1: {},
+  2: { attention: 0, agents: 0, progress: 1, open: 1, log: 0 },
+  3: { attention: 0, agents: 0, progress: 1, open: 1, log: 2 }
+};
+function placeCards(ids, n) {
+  const table = PLACEMENT[n];
+  const cols = Array.from({ length: n }, () => []);
+  for (const id of ids) cols[Math.min(n - 1, table[id] ?? n - 1)]?.push(id);
+  return cols.filter((c) => c.length > 0);
+}
+var clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+function allocateRowBudgets(availableRows, cards) {
+  const out = /* @__PURE__ */ new Map();
+  const entries = cards.map((c) => {
+    const min = Math.max(0, c.min);
+    const max = Math.max(min, c.max);
+    const count = Math.max(0, Math.floor(c.count));
+    return { id: c.id, min, max, count, natural: clamp(count, min, max) };
+  });
+  if (entries.length === 0) return out;
+  const body = Math.max(0, availableRows - FRAME_CHROME * entries.length);
+  const set = (id, n) => void out.set(id, n);
+  const naturalTotal = entries.reduce((n, e) => n + e.natural, 0);
+  if (naturalTotal <= body) {
+    for (const e of entries) set(e.id, e.natural);
+    return fillHidden(out, entries, body);
+  }
+  const minTotal = entries.reduce((n, e) => n + e.min, 0);
+  for (const e of entries) set(e.id, e.min);
+  if (body <= minTotal) return out;
+  const left = body - minTotal;
+  const weight = entries.reduce((n, e) => n + e.natural, 0);
+  const shares = entries.map((e, index) => {
+    const raw = weight === 0 ? left / entries.length : left * e.natural / weight;
+    return { e, index, raw, add: Math.min(e.max - e.min, Math.floor(raw)) };
+  });
+  let remaining = left;
+  for (const s of shares) {
+    set(s.e.id, s.e.min + s.add);
+    remaining -= s.add;
+  }
+  const byRemainder = [...shares].sort(
+    (a, b) => b.raw - Math.floor(b.raw) - (a.raw - Math.floor(a.raw)) || a.index - b.index
+  );
+  while (remaining > 0) {
+    let changed = false;
+    for (const s of byRemainder) {
+      if (remaining <= 0) break;
+      const have = out.get(s.e.id) ?? 0;
+      if (have >= s.e.max) continue;
+      set(s.e.id, have + 1);
+      remaining -= 1;
+      changed = true;
+    }
+    if (!changed) break;
+  }
+  return fillHidden(out, entries, body);
+}
+function fillHidden(out, entries, body) {
+  let spare = body - entries.reduce((n, e) => n + (out.get(e.id) ?? 0), 0);
+  while (spare > 0) {
+    const hidden = entries.map((e, index) => ({ id: e.id, index, rows: Math.max(0, e.count - (out.get(e.id) ?? 0)) })).filter((h) => h.rows > 0);
+    const total = hidden.reduce((n, h) => n + h.rows, 0);
+    if (total === 0) break;
+    const pool = Math.min(spare, total);
+    const shares = hidden.map((h) => {
+      const raw = pool * h.rows / total;
+      return { ...h, add: Math.floor(raw), rem: raw - Math.floor(raw) };
+    });
+    let given = 0;
+    for (const s of shares) {
+      out.set(s.id, (out.get(s.id) ?? 0) + s.add);
+      given += s.add;
+    }
+    shares.sort((a, b) => b.rem - a.rem || a.index - b.index);
+    for (const s of shares) {
+      if (given >= pool) break;
+      const count = entries[s.index]?.count ?? 0;
+      if ((out.get(s.id) ?? 0) >= count) continue;
+      out.set(s.id, (out.get(s.id) ?? 0) + 1);
+      given += 1;
+    }
+    if (given === 0) break;
+    spare -= given;
+  }
+  return out;
+}
+function fitColumn(availableRows, cards) {
+  const budgets = allocateRowBudgets(availableRows, cards);
+  const out = [];
+  let left = Math.max(0, Math.floor(availableRows));
+  for (const c of cards) {
+    const rows = Math.min(budgets.get(c.id) ?? 0, Math.max(0, left - FRAME_CHROME));
+    if (rows === 0 && c.min > 0 && out.length > 0) continue;
+    if (left < FRAME_CHROME) break;
+    out.push({ id: c.id, height: FRAME_CHROME + rows, rows, hidden: Math.max(0, c.count - rows) });
+    left -= FRAME_CHROME + rows;
+  }
+  return out;
+}
+
+// src/cli/tui/columns.ts
+var GUTTER = 2;
+function naturalWidths(rows, ncols) {
+  const widths = new Array(ncols).fill(0);
+  for (const row of rows) {
+    for (let i = 0; i < ncols; i++) {
+      const w = stringWidth(clean(row[i] ?? ""));
+      if (w > (widths[i] ?? 0)) widths[i] = w;
+    }
+  }
+  return widths;
+}
+function columnWidths(rows, specs) {
+  const natural = naturalWidths(rows, specs.length);
+  return specs.map((s, i) => {
+    let w = natural[i] ?? 0;
+    if (s.min !== void 0) w = Math.max(w, s.min);
+    if (s.max !== void 0) w = Math.min(w, s.max);
+    return w;
+  });
+}
+function fitCell(s, width, align = "left") {
+  const text = clean(s);
+  const w = stringWidth(text);
+  if (align === "right" && w < width) return " ".repeat(width - w) + text;
+  return cell(text, width);
+}
+function renderCells(cells, widths, specs) {
+  return specs.map((s, i) => fitCell(cells[i] ?? "", widths[i] ?? 0, s.align));
+}
+
+// src/cli/tui/rows.ts
+var TABS = [
+  { id: "overview", label: "Overview" },
+  { id: "tasks", label: "Tasks" },
+  { id: "dag", label: "DAG" },
+  { id: "agents", label: "Agents" },
+  { id: "log", label: "Log" }
+];
+var STATUS_LABELS = ["active", "open", "in_progress", "closed", "all"];
+var SORT_LABELS = ["activity", "roi", "age", "id"];
+var SORT_ARROWS = {
+  activity: "\u2193",
+  // newest first
+  roi: "\u2193",
+  // highest first
+  age: "\u2191",
+  // oldest first
+  id: "\u2191"
+};
+var NO_FILTER = { status: "active", text: "", sort: "activity" };
+var STATUS_SETS = {
+  active: ["OPEN", "IN_PROGRESS"],
+  open: ["OPEN"],
+  in_progress: ["IN_PROGRESS"],
+  closed: ["CLOSED"],
+  all: ["OPEN", "IN_PROGRESS", "CLOSED"]
+};
+var statusesOf = (label) => STATUS_SETS[label];
+function nextStatusLabel(label) {
+  const i = STATUS_LABELS.indexOf(label);
+  return STATUS_LABELS[(i + 1) % STATUS_LABELS.length] ?? "active";
+}
+function nextSortLabel(label) {
+  const i = SORT_LABELS.indexOf(label);
+  return SORT_LABELS[(i + 1) % SORT_LABELS.length] ?? "activity";
+}
+var scopeKey = (tab, workstream) => `${tab}\0${workstream ?? ""}`;
+function pickWorkstream(workstreams, hint) {
+  if (hint !== void 0 && workstreams.some((w) => w.name === hint)) return hint;
+  let best;
+  for (const w of workstreams) {
+    if (best === void 0 || w.latest_seq > best.latest_seq) best = w;
+  }
+  return best?.name ?? null;
+}
+var workstreamLabel = (w) => w.scratch ? `${w.name}*` : w.name;
+function nextLine(snap) {
+  if (snap.next_source !== "computed") return "next: unavailable";
+  if (snap.next === null) return "next: no authorised work";
+  return `next (${snap.next.mode}): ${snap.next.commands.join(" ; ")}`;
+}
+var statusText = (status, substate) => substate === "" ? status : formatPair({ status, substate });
+var scrollbackOf = (a) => ({
+  kind: "scrollback",
+  workstream: a.workstream,
+  name: a.name,
+  paneId: a.pane_id,
+  tab: a.tab
+});
+var STATUS_WIDTH = Math.max(
+  ...TASK_STATUSES.flatMap((st) => TASK_SUBSTATES[st].map((sub) => statusText(st, sub).length))
+);
+var STATE_WIDTH = "needs_permission".length;
+var HOST_WIDTH = 6;
+var LOCAL = "local";
+var TIME_WIDTH = 8;
+var protect = (min = 0, max) => ({
+  kind: "protect",
+  min,
+  ...max !== void 0 ? { max } : {}
+});
+var fixed = (n) => ({ kind: "protect", min: n, max: n });
+var CLIP = { kind: "clip" };
+function layoutRows(basis, specs) {
+  const widths = columnWidths(basis, specs);
+  const last = specs.length - 1;
+  return (cells, roles) => {
+    const fitted = renderCells(cells, widths, specs);
+    const shown = specs.flatMap(
+      (_, i) => i === last ? [{ text: clean(cells[last] ?? ""), role: roles[last] }] : (widths[i] ?? 0) > 0 ? [{ text: fitted[i] ?? "", role: roles[i] }] : []
+    );
+    const out = shown.flatMap((seg, i) => [
+      ...i > 0 ? [{ text: " ".repeat(GUTTER) }] : [],
+      seg.role === void 0 ? { text: seg.text } : { text: seg.text, role: seg.role }
+    ]);
+    while (out.length > 0) {
+      const tail = out[out.length - 1];
+      const trimmed = tail.text.trimEnd();
+      if (trimmed !== "") {
+        out[out.length - 1] = { ...tail, text: trimmed };
+        break;
+      }
+      out.pop();
+    }
+    return out;
+  };
+}
+var rowOf = (key, line, rest = {}) => ({
+  key,
+  text: lineText(line),
+  line,
+  ...rest
+});
+var ownerLabel = (t) => t.owner === null ? "" : `@${t.owner_workstream !== null && t.owner_workstream !== t.workstream ? `${t.owner_workstream}/` : ""}${t.owner}`;
+function sortTasks(tasks, sort) {
+  const roi = (t) => t.impact / Math.max(t.effort_days, 1e-9);
+  const out = [...tasks];
+  if (sort === "roi") out.sort((a, b) => roi(b) - roi(a) || a.effort_days - b.effort_days);
+  else if (sort === "age")
+    out.sort((a, b) => a.created_at < b.created_at ? -1 : a.created_at > b.created_at ? 1 : 0);
+  else if (sort === "id") out.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  return out;
+}
+function taskRows(snap, ws, f) {
+  const statuses = statusesOf(f.status);
+  const inWs = snap.tasks.filter((t) => t.workstream === ws);
+  const tasks = sortTasks(
+    inWs.filter(
+      (t) => statuses.includes(t.status) && matches(f.text, t.key, t.title, t.owner, t.substate)
+    ),
+    f.sort
+  );
+  const specs = [protect(0, 24), fixed(STATUS_WIDTH), protect(0, 24), CLIP];
+  const agentNames = snap.agents.filter((a) => a.workstream === ws).map((a) => `@${a.name}`);
+  const line = layoutRows(
+    [...inWs.map((t) => [t.id, "", ownerLabel(t)]), ...agentNames.map((n) => ["", "", n])],
+    specs
+  );
+  return tasks.map(
+    (t) => rowOf(
+      t.key,
+      line(
+        [t.id, statusText(t.status, t.substate), ownerLabel(t), t.title],
+        ["id", statusRole(t.status, t.substate), "muted", void 0]
+      ),
+      { drill: { kind: "notes", workstream: t.workstream, id: t.id, title: t.title } }
+    )
+  );
+}
+function edgeNotes(e) {
+  const notes = [
+    e.again ? "again, listed above" : "",
+    e.kids > 0 ? `+${e.kids} open` : "",
+    e.closed > 0 ? `${e.closed} closed` : "",
+    e.cap_cut > 0 ? `${e.cap_cut} cut by cap` : ""
+  ].filter((n) => n !== "");
+  return notes.length > 0 ? `  (${notes.join(", ")})` : "";
+}
+var notice = (key, text) => rowOf(key, [{ text, role: "warn" }]);
+var edgeId = (e) => `${"  ".repeat(e.depth)}${e.id}`;
+function dagRows(snap, ws, f) {
+  const rows = [];
+  const mine = snap.edges.filter((e) => e.workstream === ws);
+  const specs = [protect(0, 40), fixed(STATUS_WIDTH), CLIP];
+  const line = layoutRows(
+    mine.map((e) => [edgeId(e), "", ""]),
+    specs
+  );
+  for (const e of mine) {
+    if (matches(f.text, e.key, e.title, e.substate)) {
+      rows.push(
+        rowOf(
+          `${e.parent ?? ""}>${e.key}`,
+          [
+            ...line(
+              [edgeId(e), statusText(e.status, e.substate), e.title],
+              ["id", statusRole(e.status, e.substate), void 0]
+            ),
+            ...edgeNotes(e) === "" ? [] : [{ text: edgeNotes(e), role: "muted" }]
+          ],
+          { drill: { kind: "notes", workstream: e.workstream, id: e.id, title: e.title } }
+        )
+      );
+    } else if (e.cap_cut > 0) {
+      rows.push(
+        notice(
+          `cut:cap:${e.key}`,
+          `\u2026 ${e.cap_cut} open task${e.cap_cut === 1 ? "" : "s"} under ${e.id} left out by the node cap`
+        )
+      );
+    }
+  }
+  const cut = snap.frontier.find((c) => c.workstream === ws);
+  if (cut !== void 0 && cut.roots_cut > 0) {
+    rows.push(
+      notice(
+        "cut:roots",
+        `\u2026 ${cut.roots_cut} open start task${cut.roots_cut === 1 ? "" : "s"} left out by the node cap`
+      )
+    );
+  }
+  if (cut !== void 0 && cut.again_cut > 0) {
+    rows.push(
+      notice(
+        "cut:again",
+        `\u2026 ${cut.again_cut} repeat line${cut.again_cut === 1 ? "" : "s"} left out by the node cap`
+      )
+    );
+  }
+  return rows;
+}
+function toolText(a, now) {
+  if (a.tool === void 0) return "tool ?";
+  if (a.tool === null) return "tool -";
+  const ms = a.tool.elapsed_ms ?? now - a.tool.since;
+  return `${a.tool.name} ${formatElapsed(ms)}`;
+}
+function agentRows(snap, ws, f, now) {
+  const mine = snap.agents.filter((a) => a.workstream === ws);
+  const agents = mine.filter((a) => matches(f.text, a.key, a.state, a.tool?.name, ...a.tasks));
+  const taskOf = (a) => a.task === null ? "-" : a.task.startsWith(`${a.workstream}/`) ? a.task.slice(a.workstream.length + 1) : a.task;
+  const specs = [protect(0, 32), fixed(HOST_WIDTH), fixed(STATE_WIDTH), protect(0, 32), CLIP];
+  const line = layoutRows(
+    // The task column is as wide as the workstream's task ids, not just the tasks owned
+    // right now: an agent claiming or finishing a task must not move the tool column.
+    [
+      ...mine.map((a) => [a.name, "", "", taskOf(a)]),
+      ...snap.tasks.filter((t) => t.workstream === ws).map((t) => ["", "", "", t.id])
+    ],
+    specs
+  );
+  const flagged = (kind, key) => snap.attention.some((x) => x.kind === kind && x.target === key);
+  return agents.map(
+    (a) => rowOf(
+      a.key,
+      line(
+        [a.name, a.host ?? LOCAL, a.state ?? "?", taskOf(a), toolText(a, now)],
+        [
+          "id",
+          "muted",
+          flagged("dead", a.key) ? "bad" : agentStateRole(a.state),
+          "muted",
+          flagged("stalled", a.key) ? "warn" : "muted"
+        ]
+      ),
+      { drill: scrollbackOf(a) }
+    )
+  );
+}
+var timeOf = (iso) => /T(\d\d:\d\d:\d\d)/.exec(iso)?.[1] ?? iso;
+function logRows(snap, ws, f) {
+  const mine = snap.log.filter((l) => l.scope === ws);
+  const specs = [{ kind: "protect", align: "right" }, fixed(TIME_WIDTH), CLIP];
+  const line = layoutRows(
+    mine.map((l) => [String(l.seq), "", ""]),
+    specs
+  );
+  return mine.filter((l) => matches(f.text, l.rendered, l.actor, l.scope)).map((l) => {
+    const head = line([String(l.seq), timeOf(l.created_at), ""], ["muted", "muted", void 0]);
+    return rowOf(String(l.seq), [...head, { text: " ".repeat(GUTTER) }, ...logProse(l)], {
+      drill: { kind: "log", item: l }
+    });
+  });
+}
+var LOG_VERBS = [...KNOWN_VERBS, "task status", "op put", "op del", "op"].sort(
+  (a, b) => b.length - a.length
+);
+function logProse(l) {
+  const text = clean(l.rendered);
+  const verb = l.intent ? LOG_VERBS.find((v) => text === v || text.startsWith(`${v} `)) : void 0;
+  if (verb === void 0) return [{ text }];
+  return [
+    { text: verb, role: "verb" },
+    ...text.length > verb.length ? [{ text: text.slice(verb.length) }] : []
+  ];
+}
+function attentionLabel(a, ws) {
+  const where = a.workstream !== null && a.workstream !== ws ? `${a.workstream}/` : "";
+  return `${where}${a.kind === "human" ? `human: ${a.text}` : a.text}`;
+}
+function attentionStrip(attention, ws) {
+  if (attention.length === 0) return [{ text: "\u2713 all quiet", role: "good" }];
+  return [
+    { text: `\u26A0 ${attention.length} need you: `, role: "warn" },
+    ...attention.flatMap((a, i) => [
+      ...i > 0 ? [{ text: " \xB7 ", role: "muted" }] : [],
+      { text: attentionLabel(a, ws), role: attentionRole(a) }
+    ])
+  ];
+}
+var attentionRole = (a) => a.kind === "dead" ? "bad" : "warn";
+function attentionRows(snap, ws) {
+  return snap.attention.map((a) => {
+    const agent = snap.agents.find((x) => x.key === a.target);
+    const id = a.kind === "human" ? a.target?.slice((a.workstream?.length ?? 0) + 1) : void 0;
+    const drill = agent ? scrollbackOf(agent) : a.workstream !== null && id ? { kind: "notes", workstream: a.workstream, id, title: a.text } : void 0;
+    return rowOf(
+      a.key,
+      [{ text: attentionLabel(a, ws), role: attentionRole(a) }],
+      drill ? { drill } : {}
+    );
+  });
+}
+function tabRows(tab, snap, ws, f, now) {
+  switch (tab) {
+    case "overview":
+      return attentionRows(snap, ws);
+    case "tasks":
+      return taskRows(snap, ws, f);
+    case "dag":
+      return dagRows(snap, ws, f);
+    case "agents":
+      return agentRows(snap, ws, f, now);
+    case "log":
+      return logRows(snap, ws, f);
+  }
+}
+function cursorIndex(rows, key, tab, was) {
+  const i = key === null ? -1 : rows.findIndex((r) => r.key === key);
+  if (i >= 0) return i;
+  if (key !== null && was !== void 0) return Math.max(0, Math.min(was, rows.length - 1));
+  return tab === "log" ? Math.max(0, rows.length - 1) : 0;
+}
+function moveCursor(rows, key, tab, delta, was) {
+  if (rows.length === 0) return null;
+  const i = Math.max(0, Math.min(rows.length - 1, cursorIndex(rows, key, tab, was) + delta));
+  return rows[i]?.key ?? null;
+}
+
+// src/cli/tui/overview.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function overviewCards(snap, ws, now) {
+  const lines = (tab, f = NO_FILTER) => tabRows(tab, snap, ws, f, now).map((r) => r.line);
+  return [
+    {
+      id: "attention",
+      title: "Attention",
+      lines: lines("overview"),
+      empty: "\u2713 all quiet",
+      emptyRole: "good",
+      max: 6
+    },
+    { id: "agents", title: "Agents", lines: lines("agents"), empty: "no agents", max: 6 },
+    {
+      id: "progress",
+      title: "In progress",
+      lines: lines("tasks", { ...NO_FILTER, status: "in_progress" }),
+      empty: "nothing in progress",
+      max: 8
+    },
+    {
+      id: "open",
+      title: "Open \xB7 by ROI",
+      lines: lines("tasks", { ...NO_FILTER, status: "open", sort: "roi" }),
+      empty: "nothing open",
+      max: 12
+    },
+    { id: "log", title: "Log", lines: lines("log"), empty: "no activity", max: 10, tail: true }
+  ];
+}
+function Overview(p) {
+  const columns = placeCards(
+    p.cards.map((c) => c.id),
+    columnCount(p.width)
+  );
+  const widths = gridWidths(p.width, columns.length);
+  return /* @__PURE__ */ jsx3(Box3, { height: p.height, width: p.width, columnGap: COLUMN_GAP, children: columns.map((ids, ci) => {
+    const cards = ids.flatMap((id) => p.cards.find((c) => c.id === id) ?? []);
+    const placed = fitColumn(
+      p.height,
+      cards.map((c) => ({
+        id: c.id,
+        // Attention keeps up to 3 rows even on a short screen: it is why you look.
+        min: c.id === "attention" ? Math.max(1, Math.min(3, c.lines.length)) : 1,
+        max: c.max,
+        count: c.lines.length
+      }))
+    );
+    return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", width: widths[ci], flexShrink: 0, children: placed.map((pl) => {
+      const card = cards.find((c) => c.id === pl.id);
+      if (card === void 0) return null;
+      const attention = card.id === "attention";
+      const from = card.tail ? Math.max(0, card.lines.length - pl.rows) : attention ? scrollTop(0, p.sel, card.lines.length, pl.rows) : 0;
+      const body = card.lines.slice(from, from + pl.rows).map(
+        (l, i) => attention ? [{ text: from + i === p.sel ? "> " : "  " }, ...l] : l
+      );
+      return /* @__PURE__ */ jsx3(
+        Frame,
+        {
+          width: widths[ci] ?? 0,
+          height: pl.height,
+          title: card.title,
+          subtitle: card.lines.length > 0 ? String(card.lines.length) : "",
+          bottom: pl.hidden > 0 ? `+${pl.hidden} ${card.tail ? "older" : "more"}` : "",
+          body: card.lines.length === 0 ? [[{ text: card.empty, role: card.emptyRole ?? "muted" }]] : body,
+          ...attention && card.lines.length > 0 ? { selected: p.sel - from } : {}
+        },
+        card.id
+      );
+    }) }, ids.join());
+  }) });
+}
+
+// src/cli/tui/use-snapshot.ts
+import { useCallback, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+var SLOW_TICK_MS = 1e4;
+var TICK_FLOOR_MS = 100;
+var TICK_CEILING_MS = 1e4;
+var clampTick = (ms) => Math.max(TICK_FLOOR_MS, Math.min(TICK_CEILING_MS, ms));
+var fasterTick = (ms) => clampTick(Math.floor(ms / 2));
+var slowerTick = (ms) => clampTick(ms * 2);
+var snapshotKey = (s) => JSON.stringify(
+  s,
+  (k, v) => k === "elapsed_ms" && typeof v === "number" ? Math.floor(v / 1e3) : v
+);
+function useSnapshot(runtime, query, pollMs, slowMs = SLOW_TICK_MS) {
+  const [state, setState] = useState2({
+    loading: true,
+    error: null,
+    snapshot: null,
+    key: "",
+    nonce: 0,
+    slowNonce: 0
+  });
+  const queryKey = JSON.stringify(query);
+  const wake = useRef2(null);
+  const forceSlow = useRef2(false);
+  const published = useRef2("");
+  const lastSlow = useRef2(Number.NEGATIVE_INFINITY);
+  useEffect2(() => {
+    let cancelled = false;
+    let timer;
+    const q = JSON.parse(queryKey);
+    const loop = async () => {
+      while (!cancelled) {
+        const slow = forceSlow.current || Date.now() - lastSlow.current >= slowMs;
+        forceSlow.current = false;
+        if (slow) lastSlow.current = Date.now();
+        try {
+          const r = await runtime.refresh(q, { slow });
+          if (cancelled) return;
+          const key2 = `${queryKey}\0${snapshotKey(r.snapshot)}`;
+          const changed = key2 !== published.current;
+          published.current = key2;
+          if (changed || slow)
+            setState((s) => {
+              const next = {
+                ...s,
+                loading: false,
+                error: null,
+                key: queryKey,
+                slowNonce: slow ? s.slowNonce + 1 : s.slowNonce
+              };
+              if (!changed && s.error === null && !s.loading)
+                return { ...next, snapshot: s.snapshot };
+              return { ...next, snapshot: r.snapshot, nonce: s.nonce + 1 };
+            });
+          else
+            setState(
+              (s) => (
+                // Byte-equal and nothing to clear: the same state object, no re-render.
+                s.error === null && !s.loading ? s : { ...s, loading: false, error: null }
+              )
+            );
+        } catch (err) {
+          if (cancelled) return;
+          const error = err instanceof Error ? err.message : String(err);
+          setState((s) => s.error === error && !s.loading ? s : { ...s, loading: false, error });
+        }
+        if (pollMs === null) return;
+        await new Promise((resolve) => {
+          timer = setTimeout(resolve, pollMs);
+          wake.current = resolve;
+        });
+        wake.current = null;
+      }
+    };
+    void loop();
+    return () => {
+      cancelled = true;
+      if (timer !== void 0) clearTimeout(timer);
+      wake.current?.();
+    };
+  }, [runtime, queryKey, pollMs, slowMs]);
+  const refresh = useCallback(() => {
+    forceSlow.current = true;
+    wake.current?.();
+  }, []);
+  const { key, ...rest } = state;
+  return { ...rest, stale: state.snapshot !== null && key !== queryKey, refresh };
+}
+
+// src/cli/tui/app.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var FIXED_BY_PRIORITY = ["footer", "strip", "filter", "next"];
+var TOP_LINES = 2;
+function layout(rows, lines = FIXED_BY_PRIORITY) {
+  const spare = Math.max(0, rows - TOP_LINES - 1);
+  const shown = new Set(lines.slice(0, spare));
+  return { shown, height: Math.max(0, rows - TOP_LINES - shown.size) };
+}
+var HINT_HEAD = `\u2190/\u2192 tab  q quit  [/] workstream  ${NAV_HINT} move`;
+var HINT_OVERVIEW = `${HINT_HEAD}  Enter open  y copy  +/- rate`;
+var HINT = `${HINT_HEAD}  Enter open  / filter  c clear  y copy  +/- rate`;
+var HINT_TASKS = `${HINT_HEAD}  Enter open  s sort  o status  / filter  c clear  y copy  +/- rate`;
+var hintAgents = (attachKey) => `${HINT_HEAD}  Enter scrollback  ${attachKey}  / filter  c clear  y copy  +/- rate`;
+function workstreamSegs(labels, selected, width) {
+  const cell2 = (i) => i === selected ? `[${labels[i]}]` : ` ${labels[i]} `;
+  let first = 0;
+  const total = (from) => (from > 0 ? 1 : 0) + labels.slice(from).reduce((n, _, k) => n + stringWidth(clean(cell2(from + k))), 0);
+  while (first < selected && total(first) > width) first++;
+  return [
+    ...first > 0 ? [{ text: "\u2026", role: "muted" }] : [],
+    ...labels.flatMap(
+      (_, i) => i >= first ? [{ text: cell2(i), role: i === selected ? "title" : "muted" }] : []
+    )
+  ];
+}
+function App({
+  runtime,
+  initialWorkstream,
+  initialTab = "overview",
+  pollMs,
+  slowMs,
+  now = Date.now,
+  runStep = spawnStep
+}) {
+  const { exit, suspendTerminal } = useApp();
+  const { stdin } = useStdin();
+  const { stdout } = useStdout2();
+  const yank = useYank();
+  const [drill, setDrill] = useState3(null);
+  const busy = useRef3(false);
+  const [flash, setFlash] = useState3(null);
+  const [attachKey, setAttachKey] = useState3("a attach");
+  useEffect3(() => {
+    void attachKeyHint().then(setAttachKey);
+  }, []);
+  const { columns, rows: screenRows } = useWindowSize2();
+  const [tab, setTab] = useState3(initialTab);
+  const [chosen, setChosen] = useState3(null);
+  const [views, setViews] = useState3({});
+  const [editing, setEditing] = useState3(null);
+  const tops = useRef3({});
+  const lastSel = useRef3({});
+  const [tick, setTick] = useState3(pollMs);
+  const viewOf = (t, w) => views[scopeKey(t, w)] ?? { filter: NO_FILTER, cursor: null };
+  const known = useRef3(null);
+  const pickShown = (list) => list === null ? chosen ?? initialWorkstream ?? null : chosen !== null && list.some((w) => w.name === chosen) ? chosen : pickWorkstream(list, initialWorkstream);
+  const queryWs = pickShown(known.current);
+  const wantsClosed = tab === "tasks" && statusesOf(viewOf("tasks", queryWs).filter.status).includes("CLOSED");
+  const query = {
+    scopeWorkstream: queryWs,
+    ...wantsClosed ? { status: [...statusesOf("all")] } : {},
+    ...queryWs !== null ? { logWorkstream: queryWs } : {}
+  };
+  const state = useSnapshot(runtime, query, tick, slowMs);
+  const snap = state.snapshot;
+  const names = snap?.workstreams ?? [];
+  known.current = snap?.workstreams ?? known.current;
+  const ws = snap ? pickShown(names) : queryWs;
+  useEffect3(() => {
+    if (ws !== null && ws !== chosen) setChosen(ws);
+  }, [ws, chosen]);
+  const view = viewOf(tab, ws);
+  const all = snap ? tabRows(tab, snap, ws, view.filter, now()) : [];
+  const overview = tab === "overview";
+  const { shown, height: area } = layout(
+    screenRows,
+    // The Overview has no filter; the strip shows on every view, next to the Attention card.
+    FIXED_BY_PRIORITY.filter((l) => !(overview && l === "filter"))
+  );
+  const framed = !overview && area > FRAME_CHROME && columns > FRAME_SIDES + 2;
+  const height = framed ? area - FRAME_CHROME : area;
+  const scope = scopeKey(tab, ws);
+  const sel = cursorIndex(all, view.cursor, tab, lastSel.current[scope]);
+  lastSel.current[scope] = sel;
+  const top = scrollTop(tops.current[scope] ?? 0, sel, all.length, height);
+  tops.current[scope] = top;
+  const patch = (change, t = tab) => setViews((v) => {
+    const k = scopeKey(t, ws);
+    return { ...v, [k]: { filter: NO_FILTER, cursor: null, ...v[k], ...change } };
+  });
+  const setFilter = (change) => patch({ filter: { ...view.filter, ...change }, cursor: null });
+  const move = (delta) => patch({ cursor: moveCursor(all, view.cursor, tab, delta, lastSel.current[scope]) });
+  useEffect3(() => {
+    const key = all[sel]?.key;
+    if (view.cursor === null && tab !== "log" && !state.stale && key !== void 0)
+      setViews((v) => {
+        const k = scopeKey(tab, ws);
+        if (v[k]?.cursor != null) return v;
+        return { ...v, [k]: { filter: NO_FILTER, ...v[k], cursor: key } };
+      });
+  });
+  const cycle = (list, cur, d) => list.length === 0 ? null : list[(Math.max(0, list.indexOf(cur ?? "")) + d + list.length) % list.length] ?? null;
+  const attach = async (t) => {
+    if (busy.current) return;
+    busy.current = true;
+    setFlash(null);
+    let outcome;
+    const plan = await planAttach(t);
+    if (!plan.ok) outcome = { ok: false, reason: plan.reason, warnings: [] };
+    else {
+      outcome = { ok: false, reason: "terminal unavailable", warnings: [] };
+      try {
+        await suspendTerminal(async () => {
+          stdout.write(`${plan.notice}
+`);
+          outcome = await runAttach(plan.steps, runStep);
+          await new Promise((r) => setImmediate(r));
+          while (stdin.read() !== null) {
+          }
+          busy.current = false;
+        });
+      } catch (e) {
+        outcome = { ok: false, reason: e instanceof Error ? e.message : String(e), warnings: [] };
+      }
+    }
+    busy.current = false;
+    if (!outcome.ok)
+      setDrill({
+        target: t,
+        notice: [
+          `could not attach: ${outcome.reason}`,
+          ...plan.line === null ? [] : [`from a shell outside the mux: ${plan.line}`]
+        ]
+      });
+    else if (outcome.warnings.length > 0) setFlash(`attach: ${outcome.warnings.join("; ")}`);
+  };
+  useInput2(
+    (input, key) => {
+      if (busy.current) return;
+      setFlash(null);
+      if (editing !== null) {
+        if (key.return) setEditing(null);
+        else if (key.escape) {
+          setFilter({ text: editing.before });
+          setEditing(null);
+        } else if (key.backspace || key.delete) setFilter({ text: view.filter.text.slice(0, -1) });
+        else if (input !== "" && !key.ctrl && !key.meta)
+          setFilter({ text: view.filter.text + clean(input) });
+        return;
+      }
+      if (input === "q" || key.escape) return exit();
+      const nav = navKey(input, key, height);
+      const ids = TABS.map((t) => t.id);
+      if (key.tab || key.rightArrow || key.leftArrow) {
+        const back = key.leftArrow || key.tab && key.shift;
+        setTab(cycle(ids, tab, back ? -1 : 1) ?? tab);
+        state.refresh();
+      } else if (input === "[" || input === "]") {
+        const next = cycle(
+          names.map((w) => w.name),
+          ws,
+          input === "]" ? 1 : -1
+        );
+        if (next !== null) setChosen(next);
+      } else if (nav !== null)
+        move("by" in nav ? nav.by : nav.to === "top" ? -all.length : all.length);
+      else if (input === "s" && tab === "tasks")
+        setFilter({ sort: nextSortLabel(view.filter.sort) });
+      else if (input === "o" && tab === "tasks")
+        setFilter({ status: nextStatusLabel(view.filter.status) });
+      else if (input === "/" && !overview) setEditing({ before: view.filter.text });
+      else if (input === "c" && !overview)
+        setFilter({
+          text: "",
+          ...tab === "tasks" ? { status: "active", sort: "activity" } : {}
+        });
+      else if (input === "r") state.refresh();
+      else if ((input === "+" || input === "=" || input === "-") && tick !== null) {
+        const next = input === "-" ? slowerTick(tick) : fasterTick(tick);
+        setTick(next);
+        setFlash(`refresh every ${next >= 1e3 ? `${next / 1e3}s` : `${next}ms`}`);
+      } else if (key.return) {
+        const target = all[sel]?.drill;
+        if (target !== void 0) setDrill({ target, notice: [] });
+      } else if (input === "a" && tab === "agents") {
+        const target = all[sel]?.drill;
+        if (target?.kind === "scrollback") void attach(target);
+      } else if (input === "y") {
+        const target = all[sel]?.drill;
+        if (target !== void 0) void yank(target).then(setFlash);
+      }
+    },
+    // A drill owns the keys while it is open: App reads none.
+    { isActive: drill === null }
+  );
+  const text = (s) => cell(s, columns);
+  const attention = snap?.attention ?? [];
+  const lineOf = (r, i) => [{ text: i === sel ? "> " : "  " }, ...r.line];
+  const visible = all.slice(top, top + height);
+  const f = view.filter;
+  const filterLine = [
+    tab === "tasks" ? `status: ${f.status}` : "",
+    tab === "tasks" ? `sort: ${f.sort} ${SORT_ARROWS[f.sort]}` : "",
+    `filter: ${f.text}${editing ? "_" : ""}`,
+    snap ? `${all.length} row${all.length === 1 ? "" : "s"}` : "",
+    state.stale || state.loading && !snap ? "loading\u2026" : ""
+  ].filter((p) => p !== "").join("   ");
+  const tabIndex = TABS.findIndex((t) => t.id === tab);
+  const tabsFit = TABS.reduce((n, t) => n + t.label.length + 2, 0) <= columns;
+  const wsLabels = names.map(workstreamLabel);
+  const wsIndex = Math.max(
+    0,
+    names.findIndex((w) => w.name === ws)
+  );
+  const strip = attentionStrip(attention, ws);
+  const empty = snap === null ? state.error ? "" : "loading\u2026" : all.length === 0 ? f.text !== "" ? "no rows match the filter" : "nothing here" : "";
+  const footer = flash ? { text: flash, role: "text" } : state.error ? { text: `error: ${state.error}`, role: "bad" } : {
+    text: editing ? "type to filter  Enter keep  Esc cancel" : overview ? HINT_OVERVIEW : tab === "agents" ? hintAgents(attachKey) : tab === "tasks" ? HINT_TASKS : HINT,
+    role: "muted"
+  };
+  if (drill !== null)
+    return /* @__PURE__ */ jsx4(
+      Drill,
+      {
+        target: drill.target,
+        notice: drill.notice,
+        strip,
+        runtime,
+        busy,
+        nonce: state.nonce,
+        slowNonce: state.slowNonce,
+        onClose: () => setDrill(null),
+        onAttach: (t) => void attach(t)
+      }
+    );
+  const bodyLines = [
+    ...visible.map((r, i) => lineOf(r, top + i)),
+    ...empty ? [[{ text: `  ${empty}`, role: "muted" }]] : []
+  ];
+  const tabLabel = TABS[tabIndex]?.label ?? "";
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", height: screenRows, children: [
+    /* @__PURE__ */ jsx4(Text3, { wrap: "truncate", children: /* @__PURE__ */ jsx4(
+      Segs,
+      {
+        line: fitLine(
+          wsLabels.length > 0 ? workstreamSegs(wsLabels, wsIndex, columns) : [{ text: "no workstreams", role: "muted" }],
+          columns
+        )
+      }
+    ) }),
+    tabsFit ? /* @__PURE__ */ jsx4(Box4, { children: TABS.map((t) => /* @__PURE__ */ jsx4(Text3, { inverse: t.id === tab, ...style(t.id === tab ? "title" : "muted"), children: ` ${t.label} ` }, t.id)) }) : (
+      // Too narrow for the labels (they would wrap onto a second row): show the
+      // active one and its place.
+      /* @__PURE__ */ jsx4(Text3, { wrap: "truncate", inverse: true, ...style("title"), children: cell(` ${tabLabel} ${tabIndex + 1}/${TABS.length}`, columns) })
+    ),
+    shown.has("strip") ? /* @__PURE__ */ jsx4(Text3, { wrap: "truncate", children: /* @__PURE__ */ jsx4(Segs, { line: fitLine(strip, columns) }) }) : null,
+    shown.has("filter") ? /* @__PURE__ */ jsx4(Text3, { wrap: "truncate", ...style("muted"), children: text(filterLine) }) : null,
+    overview ? /* @__PURE__ */ jsx4(
+      Overview,
+      {
+        cards: snap ? overviewCards(snap, ws, now()) : [],
+        sel,
+        width: columns,
+        height: area
+      }
+    ) : framed ? /* @__PURE__ */ jsx4(
+      Frame,
+      {
+        width: columns,
+        height: area,
+        title: tabLabel,
+        subtitle: snap ? String(all.length) : "",
+        bottom: all.length > height ? `${sel + 1}/${all.length}` : "",
+        body: bodyLines,
+        selected: sel - top
+      }
+    ) : bodyLines.map((l, i) => (
+      // biome-ignore lint/suspicious/noArrayIndexKey: positional rows of a fixed-height viewport
+      /* @__PURE__ */ jsx4(Text3, { wrap: "truncate", children: i === sel - top ? /* @__PURE__ */ jsx4(Text3, { inverse: true, children: text(l.map((s) => s.text).join("")) }) : /* @__PURE__ */ jsx4(Segs, { line: fitLine(l, columns) }) }, i)
+    )),
+    /* @__PURE__ */ jsx4(Box4, { flexGrow: 1 }),
+    shown.has("next") ? /* @__PURE__ */ jsx4(Text3, { wrap: "truncate", ...style("muted"), children: text(snap ? nextLine(snap) : "next: unavailable") }) : null,
+    shown.has("footer") ? /* @__PURE__ */ jsx4(Text3, { wrap: "truncate", ...style(footer.role), children: text(footer.text) }) : null
+  ] });
+}
+
+// src/cli/tui/runtime.ts
+var DEFAULT_SYNC_EVERY_MS = 1e4;
+function createRuntime(opts) {
+  const ro = openDb({ path: opts.dbPath, readonly: true });
+  const now = opts.now ?? Date.now;
+  const every = opts.syncEveryMs ?? DEFAULT_SYNC_EVERY_MS;
+  let inflight = null;
+  let inflightQuery = "";
+  let lastSync = Number.NEGATIVE_INFINITY;
+  let warnings = [];
+  let seenNames = "";
+  let closed = false;
+  const agentStates = /* @__PURE__ */ new Map();
+  async function run(query, slow) {
+    if (syncEnabled() && now() - lastSync >= every) {
+      lastSync = now();
+      warnings = (await ambientIngest(opts.syncDb, { quiet: true })).warnings;
+    }
+    const names = ro.prepare("SELECT name FROM workstreams WHERE torn_down_at IS NULL ORDER BY name").all().map((w) => w.name).join("\n");
+    const activity = names !== seenNames;
+    seenNames = names;
+    const snapshot = await loadDashboard(ro, {
+      ...query,
+      activity,
+      caller: opts.caller,
+      callers: opts.callers ?? currentCallers(),
+      syncWarnings: warnings,
+      agentStates: { cache: agentStates, probe: slow }
+    });
+    return { snapshot, warnings };
+  }
+  return {
+    refresh(query = {}, { slow = false } = {}) {
+      if (closed) return Promise.reject(new Error("dashboard runtime is closed"));
+      const key = `${slow ? "slow" : "fast"}:${JSON.stringify(query)}`;
+      if (inflight !== null && inflightQuery === key) return inflight;
+      const prior = inflight?.catch(() => void 0) ?? Promise.resolve();
+      inflightQuery = key;
+      const mine = prior.then(() => run(query, slow)).finally(() => {
+        if (inflight === mine) inflight = null;
+      });
+      inflight = mine;
+      return mine;
+    },
+    notes(workstream, id, all) {
+      if (closed) throw new Error("dashboard runtime is closed");
+      return selectTaskNotes(ro, id, { workstream, all });
+    },
+    task(workstream, id) {
+      if (closed) throw new Error("dashboard runtime is closed");
+      return getTask(ro, id, workstream);
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      try {
+        await inflight?.catch(() => void 0);
+      } finally {
+        ro.close();
+      }
+    }
+  };
+}
+
+// src/cli/tui/index.ts
+async function runDashboard(opts) {
+  const runtime = createRuntime({
+    dbPath: opts.dbPath,
+    syncDb: opts.syncDb,
+    caller: spawnerFromEnv()
+  });
+  let app;
+  opts.shutdown.add(() => app?.unmount());
+  opts.shutdown.add(() => runtime.close());
+  app = render(
+    createElement(App, {
+      runtime,
+      initialWorkstream: opts.initialWorkstream ?? await resolveMuxSessionWorkstreamName() ?? void 0,
+      pollMs: opts.pollMs ?? 1e3
+    }),
+    { alternateScreen: true, interactive: true }
+  );
+  await app.waitUntilExit();
+}
+export {
+  runDashboard
+};
+//# sourceMappingURL=tui-ALPHYTA2.js.map