@songsid/agend 2.2.0-beta.2 → 2.2.0-beta.20

package/dist/backend/muse.js

@@ -90,6 +90,27 @@ const MUSE_STATUS_BAR = /^\s{1,4}[^\s·]+(?:\s+·\s+[^·\s][^·]*)+$/;
 const MUSE_DIALOG_CHROME = /Allow this (?:tool|command)|Approve this (?:tool|command)|^\s*[>❯]?\s*1\s+(?:Allow|Approve|Trust)\b|Use Up\/Down|Esc (?:quits|to cancel)|↓↑ to select|·\s*Enter to choose\b/i;
 /** The status bar is one row; a long cwd in a narrow pane wraps it onto a few more. */
 const MUSE_MAX_STATUS_ROWS = 4;
+/**
+ * #1717: extended bottom-region depth, but ONLY for a terminals-panel-headed
+ * block (header + running tasks + bar). A long wrapped bar still fails closed
+ * past MUSE_MAX_STATUS_ROWS (#958): the extension below accepts a deeper
+ * separator only when the row right after it is the panel header.
+ */
+const MUSE_MAX_PANEL_DEPTH = 8;
+/**
+ * #1717: while a background task runs, muse draws a terminals panel between
+ * the input box's bottom separator and the status bar (live 1.4.6,
+ * tests/fixtures/muse-1.4.6/prod-background-work.pane.txt):
+ *   main · ↓ to select
+ *   └ ◆ Wait in the background  running   11s
+ * The header ends in `↓ to select` — note the single arrow, which is NOT the
+ * dialog chrome's `↓↑ to select`. The timer redraws every second, which is
+ * exactly the periodic-redraw case. The composer above stays free, so the
+ * panel must not fail the idle proof — but only this shape passes: anything
+ * else under the separator still fails closed.
+ */
+const MUSE_TERMINALS_HEADER = /^.+· ↓ to select\s*$/;
+const MUSE_TERMINAL_TASK_ROW = /^[└├]\s+.*\brunning\b\s+(?:\d+(?:\.\d+)?[hms]\s*)+\s*$/;
 /** The working line's timer: `◇ Thinking (2s · esc to interrupt)`. */
 const MUSE_BUSY = /\(\s*(?:\d+(?:\.\d+)?[hms]\s*)+·\s*esc to interrupt\s*\)/;
 const MUSE_MAX_INPUT_ROWS = 200;
@@ -98,10 +119,30 @@ const MUSE_MAX_INPUT_ROWS = 200;
  * first row in the bar's grammar, the rest a wrapped continuation of it. A
  * picker, a dialog, a busy line or a second separator there means the box above
  * is not the live input (#829 review: a chooser under an old box).
+ *
+ * #1717: a terminals panel may sit between the separator and the bar (a
+ * `· ↓ to select` header plus `running` task rows). It is stripped first and
+ * each of its rows must match the panel grammar — a header with no task row,
+ * or any other shape, still fails closed.
  */
 function museStatusFooter(rows, bottomSeparator, busy) {
-    const status = rows.slice(bottomSeparator + 1);
-    if (status.length === 0 || !MUSE_STATUS_BAR.test(status[0]))
+    let status = rows.slice(bottomSeparator + 1);
+    if (status.length === 0)
+        return false;
+    if (MUSE_TERMINALS_HEADER.test(status[0])) {
+        let end = 1;
+        while (end < status.length && MUSE_TERMINAL_TASK_ROW.test(status[end]))
+            end++;
+        if (end === 1)
+            return false;
+        const panel = status.slice(0, end);
+        if (!panel.every(row => !MUSE_SEPARATOR.test(row.trim()) && !busy.test(row) && !MUSE_DIALOG_CHROME.test(row)))
+            return false;
+        status = status.slice(end);
+        if (status.length === 0)
+            return false;
+    }
+    if (!MUSE_STATUS_BAR.test(status[0]))
         return false;
     if (!status.every(row => /^\s+\S/.test(row) && !MUSE_SEPARATOR.test(row.trim()) && !busy.test(row) && !MUSE_DIALOG_CHROME.test(row)))
         return false;
@@ -109,6 +150,85 @@ function museStatusFooter(rows, bottomSeparator, busy) {
     // selection cursor under the bar is a picker, not the bar.
     return !status.slice(1).some(row => /^\s*[>❯›]?\s*\d+[.)]?\s+\S/.test(row) || /^\s*[>›]/.test(row));
 }
+/**
+ * The structural core of the idle proof, shared with the quit-menu matcher
+ * (#1730 P2-1): true when the CURRENT screen — anchored to the bottom
+ * separator — shows the live, empty input box. A transcript quoting an older
+ * screen above never satisfies it.
+ */
+function museFreeComposerLayout(rows, busyPattern) {
+    // The approval prompt is auto-answered rather than input-blocking, so the
+    // idle proof itself must refuse a frame that shows dialog chrome.
+    const dialogChrome = MUSE_DIALOG_CHROME;
+    // Everything after the bottom separator must be the status bar (#1717:
+    // optionally a terminals panel first).
+    const bottomSeparator = museBottomSeparator(rows);
+    if (bottomSeparator < 2)
+        return false;
+    if (!museStatusFooter(rows, bottomSeparator, busyPattern))
+        return false;
+    // Directly above it, the EMPTY live prompt. A `❯` with text is a draft
+    // (or, higher up, a transcript echo) and never proves idle.
+    if (!/^❯\s*$/.test(rows[bottomSeparator - 1]))
+        return false;
+    const topSeparator = bottomSeparator - 2;
+    if (!MUSE_SEPARATOR.test(rows[topSeparator]))
+        return false;
+    // No busy indicator and no dialog just above the input box. The working
+    // line (`◇ Thinking (2s · esc to interrupt)`) sits immediately above the
+    // top separator; check 8 rows up to be safe.
+    const above = rows.slice(Math.max(0, topSeparator - 8), topSeparator);
+    if (above.some(r => busyPattern.test(r) || dialogChrome.test(r)))
+        return false;
+    // Arrow-key pickers (`/model`) are refused by their component chrome
+    // above, not by guessing from answer text that happens to list model ids.
+    // A `›` selection cursor is refused too; `❯` is not a cursor here — muse
+    // echoes submitted messages with it.
+    return !above.some(r => /^\s*›\s+\S/.test(r));
+}
+/**
+ * Nearest bottom separator, with the #1717 panel extension: the plain search
+ * stays capped at MUSE_MAX_STATUS_ROWS (a 5-row wrapped bar still fails
+ * closed, #958); a deeper separator is accepted only when the row right
+ * after it is the terminals-panel header. Nearest-first, so a stale
+ * separator in scrollback can never win over the live one.
+ */
+function museBottomSeparator(rows) {
+    for (let i = rows.length - 2; i >= Math.max(0, rows.length - 1 - MUSE_MAX_STATUS_ROWS); i--) {
+        if (MUSE_SEPARATOR.test(rows[i]))
+            return i;
+    }
+    for (let i = Math.max(0, rows.length - 1 - MUSE_MAX_STATUS_ROWS) - 1; i >= Math.max(0, rows.length - 1 - MUSE_MAX_PANEL_DEPTH); i--) {
+        if (MUSE_SEPARATOR.test(rows[i])) {
+            return MUSE_TERMINALS_HEADER.test(rows[i + 1] ?? "") ? i : -1;
+        }
+    }
+    return -1;
+}
+/**
+ * #1717: true when the pane shows muse's terminals panel with at least one
+ * running task — the "local work still active" state. Anchored to the last
+ * separator, where the live panel sits under the input box: a transcript
+ * quoting an old panel above a separator never counts. The idle proof checks
+ * the same shape positionally via museStatusFooter; this boolean feeds the
+ * pause gate below.
+ */
+export function museBackgroundWorkActive(pane) {
+    const rows = pane.replace(/\r/g, "").split("\n");
+    while (rows.length && !rows[rows.length - 1].trim())
+        rows.pop();
+    let sep = -1;
+    for (let i = rows.length - 1; i >= 0; i--) {
+        if (MUSE_SEPARATOR.test(rows[i])) {
+            sep = i;
+            break;
+        }
+    }
+    if (sep < 0)
+        return false;
+    const after = rows.slice(sep + 1);
+    return after.length > 1 && MUSE_TERMINALS_HEADER.test(after[0]) && MUSE_TERMINAL_TASK_ROW.test(after[1]);
+}
 /**
  * The rows of muse's live input box, or null when the bottom of the pane is not
  * muse's layout (#829). The box is the LAST thing above the status bar:
@@ -127,13 +247,7 @@ export function museInputBox(pane, busy = MUSE_BUSY) {
     const rows = pane.replace(/\r/g, "").split("\n");
     while (rows.length && !rows[rows.length - 1].trim())
         rows.pop();
-    let bottom = -1;
-    for (let i = rows.length - 2; i >= Math.max(0, rows.length - 1 - MUSE_MAX_STATUS_ROWS); i--) {
-        if (MUSE_SEPARATOR.test(rows[i])) {
-            bottom = i;
-            break;
-        }
-    }
+    const bottom = museBottomSeparator(rows);
     if (bottom < 2 || !museStatusFooter(rows, bottom, busy))
         return null;
     for (let top = bottom - 1, n = 0; top >= 1 && n < MUSE_MAX_INPUT_ROWS; top--, n++) {
@@ -234,6 +348,288 @@ const MUSE_LOGIN_MENU = {
     inputBlocked: true,
     description: "Muse login menu — waiting for a human to log in (never answered)",
 };
+/**
+ * #1716: `/quit` while a background task runs is answered with a confirmation
+ * instead of an exit (live 1.4.6,
+ * tests/fixtures/muse-1.4.6/prod-quit-with-local-work.pane.txt):
+ *   ❯
+ *     Local work is still active
+ *     The following will stop when you exit:
+ *     background task · tool.bash
+ *     ❯ 1. Exit anyway
+ *       2. Stay
+ *     Enter to confirm · Esc to cancel
+ *   ──────────
+ *   main · ↓ to select
+ *   └ ◇ Wait in the background  running   15s
+ *     mock-model · high · ~/work · Launch overrides
+ * Unlike Claude's prompt this menu is NOT bottom-anchored — the terminals
+ * panel sits under it — so the match is anchored to the hint row instead:
+ * the header must be within 12 rows above it with both options in between.
+ * Enter would take the selected option ("Exit anyway"), so like #1217 this is
+ * recognised whole and never answered here: the stop flow cancels it.
+ */
+/**
+ * #1715: with `skip_permissions: false` muse asks before running a command
+ * needing approval (live 1.4.6,
+ * tests/fixtures/muse-1.4.6/approval-escalated.pane.txt and
+ * approval-untrusted-staged.pane.txt):
+ *   Would you like to run the following command?
+ *     $ echo perm-check
+ *   › 1. Yes, proceed (y)
+ *     2. No, and tell Muse Code what to do differently (esc)
+ *   Change approval defaults in /permissions
+ * `--approval-mode untrusted` (new in 1.4.6) stages the command first
+ * (`Stage 1/1`, `Current argv: [...]`) and offers three options (allow once /
+ * always allow in this workspace / abort). 1.4.4 shows the same prompt with a
+ * `›` marker and no footer line. Enter would take the preselected allow
+ * option, so like #1716 this is recognised whole and never answered here.
+ * 1.4.7 draws the selection cursor as `⟩` on this prompt and on the #1716
+ * quit menu (tests/fixtures/muse-1.4.7); the other rows of those blocks are
+ * unchanged.
+ */
+export const MUSE_APPROVAL_PROMPT = /^[ \t]*Would you like to run the following command\?[ \t]*$/m;
+const MUSE_APPROVAL_STAGE = /^[ \t]*Stage \d+\/\d+[ \t]*$/;
+const MUSE_APPROVAL_ARGV = /^[ \t]*Current argv: \[.*\][ \t]*$/;
+const MUSE_APPROVAL_OPT = /^[ \t]*[❯›⟩]?[ \t]*\d\.[ \t]+/;
+const MUSE_APPROVAL_FOOTER = /^[ \t]*Change approval defaults in \/permissions[ \t]*$/;
+/**
+ * #1715: which request the approval prompt is showing — its `$ command` row.
+ * Stable across the `Calling tools (Ns)` timer redraws, so the episode can
+ * confirm; a whole-pane hash never would. Derived from the SAME selected
+ * block as the predicate (#1715 r2): a scrollback quote's command must never
+ * become the current request's identity.
+ */
+export function museApprovalRequestIdentity(pane) {
+    const s = museApprovalScreen(pane);
+    if (s === null)
+        return null;
+    return museApprovalBlock(s.screen, s.top, s.bottom)?.command ?? null;
+}
+/**
+ * #1715 r2: the selected live approval block — its header row index and `$`
+ * command text. Headers are tried newest-first inside the live input block so
+ * a scrollback quote never shadows the current prompt, and the identity comes
+ * from the SAME block the predicate accepts (never a separate global search).
+ */
+function museApprovalBlock(screen, top, bottom) {
+    const window = [];
+    for (let i = bottom - 1; i > top; i--) {
+        if (screen[i].trim())
+            window.unshift({ row: screen[i], index: i });
+    }
+    for (let h = window.length - 1; h >= 0; h--) {
+        if (!MUSE_APPROVAL_PROMPT.test(window[h].row))
+            continue;
+        let k = h + 1;
+        const commandRow = k < window.length ? window[k].row : "";
+        const command = /^[ \t]*\$ (.+?)[ \t]*$/.exec(commandRow)?.[1]?.trim();
+        if (!command)
+            continue;
+        k++;
+        if (k < window.length && MUSE_APPROVAL_STAGE.test(window[k].row))
+            k++;
+        if (k < window.length && MUSE_APPROVAL_ARGV.test(window[k].row))
+            k++;
+        const last = window[window.length - 1]?.row;
+        const options = (last !== undefined && MUSE_APPROVAL_FOOTER.test(last) ? window.slice(k, -1) : window.slice(k))
+            .map(entry => entry.row);
+        if (options.length !== 2 && options.length !== 3)
+            continue;
+        if (!options.every(row => MUSE_APPROVAL_OPT.test(row)))
+            continue;
+        const first = (options[0] ?? "").replace(/^[ \t]*[❯›⟩]?[ \t]*/, "");
+        const second = options[1] ?? "";
+        if (options.length === 2) {
+            if (!/^1\. Yes, proceed \(y\)[ \t]*$/.test(first))
+                continue;
+            if (!/^[ \t]*[❯›⟩]?[ \t]*2\. No, and tell Muse Code what to do differently \(esc\)[ \t]*$/.test(second))
+                continue;
+        }
+        else {
+            if (!/^1\. Allow this stage once \(y\)[ \t]*$/.test(first))
+                continue;
+            if (!/^[ \t]*[❯›⟩]?[ \t]*2\. Always allow in this workspace: .+ \(p\)[ \t]*$/.test(second))
+                continue;
+            if (!/^[ \t]*[❯›⟩]?[ \t]*3\. Abort the entire command \(esc\)[ \t]*$/.test(options[2] ?? ""))
+                continue;
+        }
+        return { head: window[h].index, command };
+    }
+    return null;
+}
+function museApprovalScreen(pane) {
+    const screen = pane.replace(/\r/g, "").split("\n");
+    while (screen.length && !screen[screen.length - 1].trim())
+        screen.pop();
+    const bottom = museBottomSeparator(screen);
+    if (bottom < 0)
+        return null;
+    // Same ownership as the quit menu (#1730 P2-1): the prompt must live in the
+    // current input block, and a free composer means any prompt text is history.
+    let top = -1;
+    for (let i = bottom - 1; i >= 0; i--) {
+        if (MUSE_SEPARATOR.test(screen[i])) {
+            top = i;
+            break;
+        }
+    }
+    if (museFreeComposerLayout(screen, MUSE_BUSY))
+        return null;
+    // #1715 r3: any readable composer means prompt text is a quote, not the
+    // live block — the live approval panes carry no ❯ composer row at all
+    // (inputDraft null), while a quoting draft does, even one starting with a
+    // blank first row. A null draft (no readable box) carries nothing to judge,
+    // so it still proceeds.
+    if (museInputBox(pane, MUSE_BUSY) !== null)
+        return null;
+    return { screen, top, bottom };
+}
+export function museApprovalPromptActive(pane) {
+    const s = museApprovalScreen(pane);
+    return s !== null && museApprovalBlock(s.screen, s.top, s.bottom) !== null;
+}
+export const MUSE_LOCAL_WORK_QUIT = /^[ \t]*Local work is still active[ \t]*$/m;
+const MUSE_QUIT_HINT = /^[ \t]*Enter to confirm · Esc to cancel[ \t]*$/;
+const MUSE_QUIT_OPT_1 = /^[ \t]*[❯›⟩]?[ \t]*1\.[ \t]+Exit anyway[ \t]*$/m;
+const MUSE_QUIT_OPT_2 = /^[ \t]*[❯›⟩]?[ \t]*2\.[ \t]+Stay[ \t]*$/m;
+export function museLocalWorkQuitActive(pane) {
+    const screen = pane.replace(/\r/g, "").split("\n");
+    while (screen.length && !screen[screen.length - 1].trim())
+        screen.pop();
+    const bottom = museBottomSeparator(screen);
+    if (bottom < 0)
+        return false;
+    // #1730 P2-1 (refined): the menu must belong to the CURRENT input block —
+    // between the bottom separator and the nearest separator above it. Menu
+    // text quoted in an older screen is history even when the current composer
+    // is busy with a draft, not just when it is free.
+    let top = -1;
+    for (let i = bottom - 1; i >= 0; i--) {
+        if (MUSE_SEPARATOR.test(screen[i])) {
+            top = i;
+            break;
+        }
+    }
+    // A free composer on the current screen means any menu text is history.
+    if (museFreeComposerLayout(screen, MUSE_BUSY))
+        return false;
+    // #1730 P2-1 r3: a populated ❯ line means any menu text is a quote, not the
+    // live chrome. The menu only ever answers a submitted /quit, which clears
+    // the box — the live capture's ❯ row is empty with the menu as chrome under
+    // it — while every quoting draft (r2's "cancel me", r3a's hint-carrying
+    // draft, r3b's menu-quoting draft) holds text on the ❯ line itself. A null
+    // draft (no readable box) carries nothing to judge, so it still proceeds.
+    // Residual: an empty ❯ followed by a verbatim menu paste is byte-identical
+    // to the live chrome and cannot be separated here.
+    const draft = museInputBox(pane, MUSE_BUSY);
+    if (draft !== null && draft.rows.length > 0 && draft.rows[0].trim() !== "")
+        return false;
+    // Candidates newest-first, so a stale quote above never shadows the live
+    // block below (or passes as live itself).
+    for (let h = screen.length - 1; h >= 0; h--) {
+        if (!MUSE_QUIT_HINT.test(screen[h]))
+            continue;
+        if (!(h > top && h < bottom))
+            continue;
+        // The block above, skipping padding blanks (the same 12-non-blank
+        // window as before — the live menu fits in 9), with screen indices so the
+        // WHOLE block is fenced to the live input box, not just the hint: the
+        // backward scan must not borrow the header or options from above top.
+        const window = [];
+        for (let i = h - 1; i >= 0 && window.length < 12; i--) {
+            if (screen[i].trim())
+                window.unshift({ row: screen[i], index: i });
+        }
+        if (window.length < 4)
+            continue;
+        // #1730 P2-1 r4: headers newest-first, eligible only — a scrollback header
+        // above top must not shadow the live header inside the box. The first
+        // (oldest) match can sit above top while the current menu is intact below.
+        for (let head = window.length - 1; head >= 0; head--) {
+            if (!MUSE_LOCAL_WORK_QUIT.test(window[head].row))
+                continue;
+            if (window[head].index <= top)
+                continue;
+            const block = window.slice(head).map(entry => entry.row).join("\n");
+            if (!MUSE_QUIT_OPT_1.test(block) || !MUSE_QUIT_OPT_2.test(block))
+                continue;
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * #1796: the fallback `/model` set, used only when muse's on-disk provider
+ * catalog is missing or unreadable. It mirrors what the 1.4.7 picker shows
+ * (visible rows only — no `-contributor` ids); the live catalog remains the
+ * source of truth whenever it can be read.
+ */
+const MUSE_MODEL_FALLBACK = [
+    { id: "muse-wonder-1.0", label: "muse-wonder-1.0" },
+    { id: "muse-spark-1.3", label: "muse-spark-1.3" },
+    { id: "muse-spark-1.2", label: "muse-spark-1.2" },
+];
+/**
+ * #1796: read the provider catalog muse caches on disk
+ * (`<state>/model-catalog/<provider>__<profile>.json`). Bounded (at most 16
+ * files, 256 KiB each) and best-effort — anything unexpected yields the
+ * fallback. Listed rows only: `visibility: "visible"` is what the 1.4.7
+ * picker shows (the `-contributor` siblings and the image model are hidden),
+ * and a null `context_limit` additionally marks a non-chat model. File order
+ * is kept and ids deduped.
+ *
+ * `stateDir` is injectable for tests; production passes nothing and reads the
+ * host state dir (the fleet never isolates XDG_DATA_HOME, mirroring the
+ * session lookup).
+ */
+export function readMuseModelCatalog(stateDir) {
+    // Root resolution mirrors the binary, not XDG_STATE_HOME: 1.4.7 builds its
+    // state dir as `$XDG_DATA_HOME/muse` or `$HOME/.local/share/muse`
+    // (MUSE_SESSIONS uses the same root).
+    const base = process.env.XDG_DATA_HOME
+        ? join(process.env.XDG_DATA_HOME, "muse")
+        : join(homedir(), ".local", "share", "muse");
+    const dir = join(stateDir ?? base, "model-catalog");
+    try {
+        const files = readdirSync(dir).filter(f => f.endsWith(".json")).sort().slice(0, 16);
+        if (files.length === 0)
+            return [...MUSE_MODEL_FALLBACK];
+        const seen = new Set();
+        const out = [];
+        for (const file of files) {
+            const path = join(dir, file);
+            try {
+                if (statSync(path).size > 262_144)
+                    continue;
+                const parsed = JSON.parse(readFileSync(path, "utf-8"));
+                const rows = parsed.rows;
+                if (!Array.isArray(rows))
+                    continue;
+                for (const row of rows.slice(0, 256)) {
+                    const r = row;
+                    if (typeof r.model_id !== "string" || r.model_id === "" || r.visibility !== "visible")
+                        continue;
+                    // A `-contributor` suffix is a legacy spelling of contributor mode,
+                    // not a model — excluded even if some profile ever marks it visible.
+                    if (r.model_id.endsWith("-contributor"))
+                        continue;
+                    if (r.context_limit == null)
+                        continue;
+                    if (seen.has(r.model_id))
+                        continue;
+                    seen.add(r.model_id);
+                    out.push({ id: r.model_id, label: typeof r.display_label === "string" && r.display_label !== "" ? r.display_label : r.model_id });
+                }
+            }
+            catch { /* one bad file never hides the rest */ }
+        }
+        return out.length > 0 ? out : [...MUSE_MODEL_FALLBACK];
+    }
+    catch {
+        return [...MUSE_MODEL_FALLBACK];
+    }
+}
 /**
  * Meta Muse Code — the `muse` CLI (v1.3.0 verified).
  *
@@ -559,41 +955,7 @@ export class MuseBackend {
         const rows = pane.replace(/\r/g, "").split("\n");
         while (rows.length && !rows[rows.length - 1].trim())
             rows.pop();
-        const separator = MUSE_SEPARATOR;
-        const busyPattern = this.getBusyPattern();
-        // The approval prompt is auto-answered rather than input-blocking, so the
-        // idle proof itself must refuse a frame that shows dialog chrome.
-        const dialogChrome = MUSE_DIALOG_CHROME;
-        // Everything after the bottom separator must be the status bar.
-        let bottomSeparator = -1;
-        for (let i = rows.length - 2; i >= Math.max(0, rows.length - 1 - MUSE_MAX_STATUS_ROWS); i--) {
-            if (separator.test(rows[i])) {
-                bottomSeparator = i;
-                break;
-            }
-        }
-        if (bottomSeparator < 2)
-            return false;
-        if (!museStatusFooter(rows, bottomSeparator, busyPattern))
-            return false;
-        // Directly above it, the EMPTY live prompt. A `❯` with text is a draft
-        // (or, higher up, a transcript echo) and never proves idle.
-        if (!/^❯\s*$/.test(rows[bottomSeparator - 1]))
-            return false;
-        const topSeparator = bottomSeparator - 2;
-        if (!separator.test(rows[topSeparator]))
-            return false;
-        // No busy indicator and no dialog just above the input box. The working
-        // line (`◇ Thinking (2s · esc to interrupt)`) sits immediately above the
-        // top separator; check 8 rows up to be safe.
-        const above = rows.slice(Math.max(0, topSeparator - 8), topSeparator);
-        if (above.some(r => busyPattern.test(r) || dialogChrome.test(r)))
-            return false;
-        // Arrow-key pickers (`/model`) are refused by their component chrome
-        // above, not by guessing from answer text that happens to list model ids.
-        // A `›` selection cursor is refused too; `❯` is not a cursor here — muse
-        // echoes submitted messages with it.
-        return !above.some(r => /^\s*›\s+\S/.test(r));
+        return museFreeComposerLayout(rows, this.getBusyPattern());
     }
     getErrorPatterns() {
         // NOTE: an Escape-interrupted run prints "interrupting run" in the status
@@ -659,6 +1021,31 @@ export class MuseBackend {
                 keys: ["1", "Enter"],
                 description: "Muse tool approval — allow",
             },
+            {
+                // #1715: never answered here. Enter would take the preselected allow
+                // option, so the human must choose. The prompt replaces the input
+                // box (no draft to clear, unlike #829); deliveries simply hold.
+                pattern: MUSE_APPROVAL_PROMPT,
+                isActive: museApprovalPromptActive,
+                requestIdentity: museApprovalRequestIdentity,
+                interactionKind: "permission",
+                keys: [],
+                holdOnly: true,
+                blocksDelivery: true,
+                inputBlocked: true,
+                description: "Muse approval prompt — waiting for a human choice, never auto-approving",
+            },
+            {
+                // #1716: never answered here. A delivery's Enter would pick
+                // "Exit anyway"; the stop flow cancels it (Escape, then SIGTERM).
+                pattern: MUSE_LOCAL_WORK_QUIT,
+                isActive: museLocalWorkQuitActive,
+                keys: [],
+                holdOnly: true,
+                blocksDelivery: true,
+                inputBlocked: true,
+                description: "Muse \"Local work is still active\" quit menu — holding, never answering with Enter",
+            },
         ];
     }
     getContextUsage() {
@@ -726,6 +1113,19 @@ export class MuseBackend {
     getQuitCommand() { return "/quit"; }
     getQuitKey() { return "C-c"; }
     getQuitKeyPresses() { return 2; }
+    /** #1716: `/quit` with a background task running stops at the "Local work is still active" menu. */
+    quitBlockedByDialog(pane) {
+        return museLocalWorkQuitActive(pane);
+    }
+    /**
+     * #1717: the terminals panel with a `running` task — the pause flow defers
+     * an idle pause while this holds, so an AgEnD-initiated silent pause never
+     * kills the user's running background work. Explicit stop/restart still
+     * proceed via quitBlockedByDialog above.
+     */
+    backgroundWorkRunning(pane) {
+        return museBackgroundWorkActive(pane);
+    }
     getCompactCommand() { return "/compact"; }
     getClearCommand() { return "/clear"; }
     /**
@@ -773,15 +1173,11 @@ export class MuseBackend {
     async listModels() {
         // muse has no models subcommand (the command table is: resume, exec,
         // config, export, trace, skills, plugins, sandbox, schema, serve,
-        // session-message, mcp, auth, login, logout, init). This set was read off
-        // the live `/model` picker; the `-contributor` variants are the same models
-        // with content sharing enabled, which the picker spells out.
-        return [
-            { id: "muse-spark-1.3", label: "muse-spark-1.3" },
-            { id: "muse-spark-1.3-contributor", label: "muse-spark-1.3-contributor (shares content)" },
-            { id: "muse-spark-1.2", label: "muse-spark-1.2" },
-            { id: "muse-spark-1.2-contributor", label: "muse-spark-1.2-contributor (shares content)" },
-        ];
+        // session-message, mcp, auth, login, logout, init). The live `/model`
+        // picker reads the provider catalog muse caches on disk (#1796), so this
+        // reads the same files — bounded and best-effort, falling back to the
+        // last known set when the cache is missing or unreadable.
+        return readMuseModelCatalog();
     }
     async probeCLIEnv() {
         const { probeCliVersion } = await import("./types.js");