aibroker 0.61.9 → 0.62.4

package/dist/daemon/manage.js

@@ -25,10 +25,11 @@ import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { log } from "../core/log.js";
 import { timeCall } from "../core/call-timing.js";
-import { readSessionContent } from "./session-content.js";
+import { readSessionContent, readSessionContentAsync } from "./session-content.js";
 import { typeIntoSession, pasteTextIntoSession, sendControlU, sendEnterKey, escapeInputMode, wasLastEnumerationReliable } from "../transport/sync-facade.js";
 import { findItermBundleIdImpostors } from "../adapters/iterm/core.js";
 import { processCwd } from "../core/bins.js";
+import { parseAttachUuid, parseSessionIdArg } from "../core/claude-attach.js";
 import { discoverLiveSessions } from "../core/session-discovery.js";
 import { hasPailotClients } from "../adapters/pailot/gateway.js";
 import { getAibpBridge } from "../core/state.js";
@@ -100,8 +101,8 @@ const GOAL_ACTIVE = /\/goal\s+active/i;
  * because composing one is exactly the sort of work it no longer has room
  * for. The margin has to be big enough to write in.
  */
-const HANDOVER_MARGIN_K_DEFAULT = 100; // warm-up band: ask this far below the trigger, given time or work done
-const REFRESH_MARGIN_K = 40; // refresh band: ask again if it has grown 40k+ since the last one
+const HANDOVER_MARGIN_K_DEFAULT = 50; // warm-up band: ask this far below the trigger, given time or work done
+const REFRESH_MARGIN_K = 30; // refresh band: ask again if it has grown 40k+ since the last one
 const REFRESH_GROWN_K = 40;
 const IMMEDIATE_MARGIN_K = 15; // immediate band: ask NOW, no gating — this close, waiting is the wrong trade
 /**
@@ -281,6 +282,12 @@ const HANDOVER_REASK_K = 120;
  * growth its own last handover caused.
  */
 const HANDOVER_MIN_GAP_MS = 8 * 60_000;
+/**
+ * Least new work (K tokens) since the last confirmed handover before another
+ * is asked for in the warm-up band (refresh needs 40k, immediate is ungated). The log showed re-asks with 3k of new work: a
+ * handover that age-by-clock alone justified, with nothing new to write down.
+ */
+const HANDOVER_MIN_NEW_K = 20;
 /**
  * Input the terminal is holding rather than running.
  *
@@ -411,7 +418,7 @@ function mirrorToRepo(m) {
         const proc = tty ? processReading(tty) : { isSession: false, pid: null };
         if (!proc.pid)
             return;
-        const live = repoRootFor(proc.pid);
+        const live = repoRootFor(proc.pid, proc.uuid);
         if (!live)
             return;
         // Pin on the first successful resolution — including for sessions that
@@ -550,12 +557,12 @@ export function bandOf(usedK, effectiveK, marginK) {
  *   nothing is one redundant note, the cost of NOT asking is the session
  *   compacting before it writes anything down.
  *
- *   REFRESH (trigger − 40k) — due once REFRESH_GROWN_K of new work has
+ *   REFRESH (trigger − 30k) — due once REFRESH_GROWN_K of new work has
  *   landed since the last handover, regardless of the clock. A handover
  *   this close to the trigger that predates a lot of new work is stale
  *   exactly where staleness costs the most.
  *
- *   WARM-UP (trigger − marginK, default 100k) — the ordinary case, gated the
+ *   WARM-UP (trigger − marginK, default 50k) — the ordinary case, gated the
  *   same way as before this was split into bands: due by the CLOCK
  *   (`lastAskAt` old enough) or by WORK done since the last one.
  *
@@ -595,6 +602,11 @@ export function handoverDue(input) {
         return { due: true, reason: "refresh" };
     }
     const sinceLast = input.now - (input.lastAskAt ?? 0);
+    // The immediate band stays ungated (this close to the wall, waiting is the
+    // wrong trade); warm-up by clock needs real new work, not 3k.
+    if (used >= warmUpK && grownBy !== undefined && grownBy < HANDOVER_MIN_NEW_K) {
+        return { due: false, reason: `only ${grownBy}k of new work since the last handover (min ${HANDOVER_MIN_NEW_K}k)` };
+    }
     const dueByTime = sinceLast > HANDOVER_REASK_MS;
     const dueByWork = grownBy !== undefined && grownBy >= HANDOVER_REASK_K && sinceLast > HANDOVER_MIN_GAP_MS;
     if (used >= warmUpK && (dueByTime || dueByWork)) {
@@ -684,6 +696,12 @@ export function typedLineMatches(readBack, intended) {
     if (normalizedReadBack.startsWith(normalizedIntended)) {
         return true;
     }
+    // A terminal that wraps mid-word makes the join add a space inside a word;
+    // compare with all whitespace removed as well.
+    const squash = (t) => t.replace(/\s+/g, "");
+    if (squash(normalizedReadBack).startsWith(squash(normalizedIntended))) {
+        return true;
+    }
     // Strip Claude Code paste placeholder.
     const placeholder = /^\[Pasted text #\d+\]\s*/;
     const collapsed = placeholder.test(normalizedReadBack);
@@ -695,7 +713,8 @@ export function typedLineMatches(readBack, intended) {
     }
     // Tail match: read-back appears as the end of intended, if long enough.
     if (strippedReadBack.length >= 30 &&
-        normalizedIntended.endsWith(strippedReadBack)) {
+        (normalizedIntended.endsWith(strippedReadBack) ||
+            squash(normalizedIntended).endsWith(squash(strippedReadBack)))) {
         return true;
     }
     return false;
@@ -828,7 +847,10 @@ function clearLanded(m) {
  */
 export function promptUnsentText(content) {
     const lines = content.split("\n");
-    for (let i = 1; i < lines.length; i++) {
+    // Bottom-up: the live box is the LAST rule-framed ❯ line. An older box
+    // remnant in scrollback (a redraw) must never outvote it, even when the
+    // live one is empty.
+    for (let i = lines.length - 1; i >= 1; i--) {
         // The rule may carry a title — "──── Name ──" — so match its start, not
         // the whole line. Requiring the run of box-drawing characters up front
         // keeps this from matching prose that happens to begin with a dash.
@@ -838,10 +860,21 @@ export function promptUnsentText(content) {
         const m = lines[i].match(/^\s*❯\s*(.*)$/);
         if (!m)
             continue;
-        const typed = m[1].trim();
+        // A line longer than the pane wraps onto continuation lines inside the
+        // box, down to the closing rule; the unsent text is all of them. Without
+        // a closing rule (cut-off capture) only the ❯ line is trusted.
+        const parts = [m[1].trim()];
+        for (let j = i + 1; j < lines.length; j++) {
+            if (/^\s*[─—-]{10,}/.test(lines[j]))
+                break;
+            parts.push(lines[j].trim());
+            if (j === lines.length - 1)
+                parts.length = 1;
+        }
+        const typed = parts.filter(Boolean).join(" ");
         // The terminal's own hint about held input is not the operator's text.
         if (!typed || /^press up to edit/i.test(typed))
-            continue;
+            return null;
         return typed;
     }
     return null;
@@ -933,11 +966,11 @@ function repoRootForSession(sessionId) {
     const proc = processReading(tty);
     if (!proc.pid)
         return undefined;
-    return repoRootFor(proc.pid) ?? undefined;
+    return repoRootFor(proc.pid, proc.uuid) ?? undefined;
 }
-function repoRootFor(pid) {
+function repoRootFor(pid, uuid) {
     try {
-        const cwd = processCwd(pid);
+        const cwd = sessionProjectCwd(pid, uuid);
         if (!cwd)
             return null;
         const root = execFileSync("/usr/bin/env", ["git", "-C", cwd, "rev-parse", "--show-toplevel"], {
@@ -1085,6 +1118,25 @@ const lastContextLog = new Map();
  * GHOST_TICKS more ticks, never causes one to fire early.
  */
 const inputLineTracking = new Map();
+/**
+ * The report's lines: one per UNPAUSED session, resetting its arming counter.
+ * `kOf` is injectable so the policy can be tested without a live terminal.
+ */
+export function reportLines(managed, armingsSince, now, kOf = contextK) {
+    const mins = Math.round(REPORT_EVERY_MS / 60_000);
+    return managed.filter((m) => !m.paused).map((m) => {
+        const armings = armingsSince.get(m.sessionId) ?? 0;
+        armingsSince.set(m.sessionId, 0);
+        const k = kOf(m);
+        const quietFor = Math.round((now - m.lastChangeAt) / 60_000);
+        const doing = quietFor >= 2 ? `quiet for ${quietFor} min` : "working";
+        const last = m.history.at(-1);
+        return (`• ${m.name} — ${doing}` +
+            (k !== null ? `, ${k}k context` : "") +
+            `, ${armings} arming${armings === 1 ? "" : "s"} in ${mins} min` +
+            (last ? `\n  last: ${last.what.slice(0, 110)}` : ""));
+    });
+}
 /**
  * The periodic reading: what every managed session is doing, in one message.
  *
@@ -1109,19 +1161,14 @@ function reportIfDue(now) {
     if (now - lastReportAt < REPORT_EVERY_MS)
         return;
     lastReportAt = now;
-    const mins = Math.round(REPORT_EVERY_MS / 60_000);
-    const lines = managed.map((m) => {
-        const armings = armingsSinceReport.get(m.sessionId) ?? 0;
-        armingsSinceReport.set(m.sessionId, 0);
-        const k = contextK(m);
-        const quietFor = Math.round((now - m.lastChangeAt) / 60_000);
-        const doing = m.paused ? "paused" : quietFor >= 2 ? `quiet for ${quietFor} min` : "working";
-        const last = m.history.at(-1);
-        return (`• ${m.name} — ${doing}` +
-            (k !== null ? `, ${k}k context` : "") +
-            `, ${armings} arming${armings === 1 ? "" : "s"} in ${mins} min` +
-            (last ? `\n  last: ${last.what.slice(0, 110)}` : ""));
-    });
+    // A paused manager does nothing, so there is nothing to say about it.
+    for (const m of managed)
+        if (m.paused)
+            armingsSinceReport.set(m.sessionId, 0);
+    const lines = reportLines(managed, armingsSinceReport, now);
+    // Only paused sessions: nothing to report, clock already held at now above.
+    if (lines.length === 0)
+        return;
     reportToOperator(`Manager report\n${lines.join("\n")}`);
 }
 /**
@@ -1212,7 +1259,8 @@ function processReading(tty) {
     const claude = rows.find((r) => /(^|\/)claude$/.test(r.cmd.split(/\s+/)[0]));
     if (!claude)
         return { isSession: false, pid: null };
-    return { isSession: true, pid: claude.pid };
+    // A `claude attach <id>` viewer's cwd is not the session's; the id is.
+    return { isSession: true, pid: claude.pid, uuid: parseAttachUuid(claude.cmd) ?? parseSessionIdArg(claude.cmd) };
 }
 /**
  * Pure extraction of context usage from raw transcript JSONL lines.
@@ -1277,19 +1325,82 @@ export function usageFromLines(lines) {
 function sessionCwd(claudePid) {
     return processCwd(claudePid);
 }
+/**
+ * The session's project directory. A `claude attach` viewer sits in HOME, so
+ * its process cwd names no project; the transcript named by the session id
+ * records the real one in the `cwd` of its newest record. Process cwd is the
+ * fallback when the id is unknown or the transcript carries no cwd.
+ */
+export function sessionProjectCwd(claudePid, uuid, root, procCwd = sessionCwd) {
+    const file = uuid ? sessionTranscriptFile(uuid, root) : null;
+    if (file) {
+        try {
+            const tail = execFileSync("/usr/bin/tail", ["-n", "200", file], { encoding: "utf8", timeout: 4_000, maxBuffer: 8 * 1024 * 1024 });
+            const lines = tail.split("\n");
+            for (let i = lines.length - 1; i >= 0; i--) {
+                try {
+                    const cwd = JSON.parse(lines[i]).cwd;
+                    if (typeof cwd === "string" && cwd)
+                        return cwd;
+                }
+                catch { /* blank or truncated line */ }
+            }
+        }
+        catch { /* unreadable transcript: fall back */ }
+    }
+    return procCwd(claudePid);
+}
 /**
  * The transcript directory for a session's own project, derived from its cwd.
  * Shared by transcriptReading (the live session's own tail) and the
  * measured-compaction reading (every .jsonl in the project, not only the
  * live one).
  */
-function projectTranscriptDir(claudePid) {
+function projectTranscriptDir(claudePid, uuid) {
+    const byId = uuid ? sessionTranscriptFile(uuid) : null;
+    if (byId)
+        return dirname(byId);
     const cwd = sessionCwd(claudePid);
     if (!cwd)
         return null;
     const dir = join(homedir(), ".claude", "projects", cwd.replace(/\//g, "-"));
     return existsSync(dir) ? dir : null;
 }
+const transcriptFileCache = new Map();
+/**
+ * The transcript named by a Claude session id (full uuid or the short prefix
+ * `claude attach` takes), found under any project dir. The id is the only
+ * thing that identifies a background session's file: its viewer process sits
+ * in HOME, so the cwd-derived project dir is some other session's. Cached per
+ * id; re-resolved when the cached file is gone.
+ */
+export function sessionTranscriptFile(uuid, root = join(homedir(), ".claude", "projects")) {
+    const key = `${root}\0${uuid.toLowerCase()}`;
+    const cached = transcriptFileCache.get(key);
+    if (cached && existsSync(cached))
+        return cached;
+    transcriptFileCache.delete(key);
+    try {
+        const prefix = uuid.toLowerCase();
+        for (const d of readdirSync(root)) {
+            let names;
+            try {
+                names = readdirSync(join(root, d));
+            }
+            catch {
+                continue;
+            }
+            const hit = names.find((f) => f.endsWith(".jsonl") && f.toLowerCase().startsWith(prefix));
+            if (hit) {
+                const path = join(root, d, hit);
+                transcriptFileCache.set(key, path);
+                return path;
+            }
+        }
+    }
+    catch { /* no projects dir */ }
+    return null;
+}
 /**
  * Where a handover goes when nobody has named a file — the convention this
  * project already uses without the manager's help, so a session asked cold
@@ -1304,6 +1415,47 @@ export function defaultHandoverTarget(cwd, notesDirExists) {
         return null;
     return join(cwd, "Notes", "TODO.md");
 }
+/**
+ * The project's configured handover sink, from `.pai/project.yaml`
+ * (`status.sink: forge` + `status.forge.anchor` / `repo`, the schema PAI's
+ * forge-sink owns). Null for the default `todo` sink or no file, so the
+ * caller falls through to Notes/TODO.md. Walks up from the session's cwd.
+ * ponytail: line scan, not a YAML parse — only three scalar keys are read;
+ * switch to the yaml package if the schema grows structure.
+ */
+export function projectSinkDescription(cwd) {
+    let dir = cwd;
+    for (let i = 0; dir && i < 8; i++, dir = dirname(dir) === dir ? null : dirname(dir)) {
+        const file = join(dir, ".pai", "project.yaml");
+        if (!existsSync(file))
+            continue;
+        let text;
+        try {
+            text = readFileSync(file, "utf8");
+        }
+        catch {
+            return null;
+        }
+        const key = (k) => text.match(new RegExp(`^\\s+${k}:\\s*["']?([^\\s#"']+)`, "m"))?.[1];
+        if (key("sink") !== "forge")
+            return null;
+        const anchor = key("anchor");
+        const repo = key("repo");
+        return (`the forge handover issue named by the anchor${anchor ? ` #${anchor}` : ""}${repo ? ` in ${repo}` : ""} ` +
+            `(this project's status sink in .pai/project.yaml) — replace the section between <!-- pai:continue --> and <!-- /pai:continue --> in it`);
+    }
+    return null;
+}
+/** Precedence: explicit handoverFile > project status sink > Notes/TODO.md default. */
+export function pickHandoverTarget(i) {
+    if (i.handoverFile)
+        return { path: resolveHandoverPath(i.handoverFile), source: "explicit" };
+    if (i.sinkDescription)
+        return { description: i.sinkDescription, source: "project sink" };
+    if (i.defaultPath)
+        return { path: i.defaultPath, source: "default" };
+    return { source: "none" };
+}
 /**
  * The live transcript's tail. File mtime is not evidence of life: a stale
  * transcript keeps getting non-message records appended. Among the five most
@@ -1338,16 +1490,28 @@ export function liveTranscriptTail(dir) {
     }
     return best;
 }
-function transcriptReading(claudePid) {
+function transcriptReading(claudePid, uuid) {
     const none = { working: null, doing: null, contextK: null, lastAt: null };
     try {
-        const dir = projectTranscriptDir(claudePid);
-        if (!dir)
-            return none;
-        const picked = liveTranscriptTail(dir);
-        if (!picked)
-            return none;
-        const raw = picked.raw;
+        // The file named by the session id wins; the newest-in-project guess is
+        // only for a session whose id is not known.
+        const byId = uuid ? sessionTranscriptFile(uuid) : null;
+        let raw;
+        let file;
+        if (byId) {
+            raw = execFileSync("/usr/bin/tail", ["-n", "200", byId], { encoding: "utf8", timeout: 4_000, maxBuffer: 8 * 1024 * 1024 });
+            file = byId;
+        }
+        else {
+            const dir = projectTranscriptDir(claudePid);
+            if (!dir)
+                return none;
+            const picked = liveTranscriptTail(dir);
+            if (!picked)
+                return none;
+            raw = picked.raw;
+            file = join(dir, picked.file);
+        }
         const msgs = [];
         for (const line of raw.split("\n")) {
             if (!line.trim())
@@ -1379,7 +1543,7 @@ function transcriptReading(claudePid) {
         // above so the pure extraction stays the single source of truth for what
         // counts as "no usage" — duplicating the parse is cheap against 40 lines.
         const contextK = usageFromLines(raw.split("\n")) ?? null;
-        return { working, doing, contextK, lastAt };
+        return { working, doing, contextK, lastAt, file };
     }
     catch {
         return none;
@@ -1515,25 +1679,40 @@ function compactionReading(m, pid, dir) {
  * which number came from the transcript and which was scraped off a status bar
  * cannot tell which one to doubt.
  */
+function fmtAge(ms) {
+    const s = Math.round(ms / 1000);
+    return s < 90 ? `${s}s` : `${Math.round(s / 60)} min`;
+}
 function liveReading(sessionId, idleSec, m) {
     const snap = discoverLiveSessions().find((s) => s.id === sessionId);
     const proc = snap?.tty ? processReading(snap.tty) : { isSession: false, pid: null };
     if (!proc.isSession) {
         return "  no session process on that pane — it is a bare shell, or the session has exited";
     }
-    const t = proc.pid ? transcriptReading(proc.pid) : { working: null, doing: null, contextK: null, lastAt: null };
+    const uuid = proc.uuid ?? snap?.attachUuid;
+    const t = proc.pid
+        ? transcriptReading(proc.pid, uuid)
+        : { working: null, doing: null, contextK: null, lastAt: null };
     const out = [];
     if (t.lastAt !== null) {
         const agoSec = Math.round((Date.now() - t.lastAt) / 1000);
         out.push(`  ${t.working ? "working" : "idle"} · last transcript entry ${agoSec < 90 ? `${agoSec}s` : `${Math.round(agoSec / 60)} min`} ago` +
             (t.doing ? ` · ${t.doing}` : ""));
+        if (t.file) {
+            let age = "";
+            try {
+                age = `, written ${fmtAge(Date.now() - statSync(t.file).mtimeMs)} ago`;
+            }
+            catch { /* gone */ }
+            out.push(`  transcript ${t.file}${age}`);
+        }
         if (t.contextK !== null) {
             out.push(`  context ${t.contextK}k tokens (from the transcript's own usage, not the status bar)`);
             // The trigger, fill rate and ETA are only meaningful alongside a
             // session's own margin, so all three are printed together and only
             // when a managed session (`m`) is available to supply it.
             if (m) {
-                const dir = proc.pid ? projectTranscriptDir(proc.pid) : null;
+                const dir = proc.pid ? projectTranscriptDir(proc.pid, uuid) : null;
                 const { effectiveK, label } = compactionReading(m, proc.pid, dir);
                 const marginK = resolvedMarginK(m);
                 const warmUpK = Math.round(effectiveK - marginK);
@@ -1643,8 +1822,8 @@ export function oneLine(text) {
 function landsWhen(m) {
     if (m.paused)
         return "  The manager is paused — nothing is armed until you resume it.";
-    return ("  This changes what the next arming says; it types nothing now.\n" +
-        "  The next arming comes when the session stops — or immediately, with `now`.");
+    return ("  This arms on the next tick — every ask is now, and a line typed at a\n" +
+        "  session mid-turn queues at the turn boundary and interrupts nothing.");
 }
 /**
  * Standing rules: how to work, written once, typed at every arming.
@@ -1892,6 +2071,228 @@ export function parseShift(text, now = new Date()) {
         workers: Math.min(8, Math.max(1, workers)),
     };
 }
+// ── self-supervision: one call from the session itself ───────────────────────
+/** "self" or omitted means the caller's own session; anything else is taken as given. */
+export function resolveManageTarget(session, callerId) {
+    const s = (session ?? "").trim();
+    return !s || s.toLowerCase() === "self" ? (callerId ?? null) : s;
+}
+/** Put goal / until / every on a managed entry; the screen is never granted by supervise. */
+export function applySupervise(m, goal, until, every) {
+    if (goal) {
+        m.objective = goal;
+        m.pending = [];
+        m.lastRearmAt = 0;
+    }
+    if (every !== null)
+        m.nudgeEveryMin = every;
+    if (until !== null)
+        m.shift = { until, workers: 1, visual: false, startedAt: Date.now(), plain: true };
+    m.paused = false;
+    note(m, `supervise: until ${until !== null ? hhmm(until) : "open-ended"}, nudge every ${m.nudgeEveryMin ?? "-"} min`);
+}
+/**
+ * Change the standing objective on a managed entry.
+ *
+ * EVERY ask for arming is now (2026-10-17 14:48), and a changed objective is
+ * an ask: the new text must reach the session, not whenever the lapse timer
+ * next gets around to it, but on the very next tick. `0` is the sentinel the
+ * arm gates read as "arm now" — idle or queued behind a running turn, which
+ * is safe because a queued line lands at the turn boundary and interrupts
+ * nothing.
+ */
+export function setObjective(m, objective) {
+    m.objective = objective;
+    m.lastRearmAt = 0;
+}
+/**
+ * Queue an operator instruction, and demand the arming that delivers it.
+ *
+ * The queue only goes out with an arming, so an instruction that did not
+ * demand one waited for the lapse timer — an arming that had nothing to do
+ * with what the operator just said, and one they may wait the better part of
+ * an hour for. Every ask is now: the instruction rides out on the next tick.
+ */
+export function queueInstruction(m, instruction) {
+    m.pending.push(instruction);
+    m.lastRearmAt = 0;
+}
+// ── only the operator ends or shortens a goal ────────────────────────────────
+export const AGENT_REFUSAL = 'refused: only the operator ends or shortens a goal (say "manage <session> off" yourself in a session, or run it from your own terminal)';
+const TOKEN_TTL_MS = 5 * 60_000;
+const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+const tokenDir = () => join(homedir(), ".aibroker", "operator-tokens");
+/** Written by hooks/operator-manage-token.mjs from the operator's own typed prompt. */
+export function writeOperatorToken(session, action, now = Date.now()) {
+    mkdirSync(tokenDir(), { recursive: true, mode: 0o700 });
+    writeFileSync(join(tokenDir(), `${slug(session)}-${action}.json`), JSON.stringify({ expiresAt: now + TOKEN_TTL_MS }), { mode: 0o600 });
+}
+/** One-shot: the file is removed whether or not it was still valid. */
+function consumeToken(sessions, action, now) {
+    let ok = false;
+    for (const s of new Set(sessions.map(slug).filter(Boolean))) {
+        const file = join(tokenDir(), `${s}-${action}.json`);
+        try {
+            ok = JSON.parse(readFileSync(file, "utf8")).expiresAt > now || ok;
+            unlinkSync(file);
+        }
+        catch { /* no token under this name */ }
+    }
+    return ok;
+}
+/**
+ * Agents cannot end or shorten a goal. Returns the refusal, or null when the
+ * call may go ahead. `operator` is set only by the CLI (outside any agent
+ * environment) and by the prompt hook; otherwise a one-shot token written from
+ * the operator's typed prompt is required.
+ * ponytail: a process that writes the daemon socket directly can still claim
+ * `operator`; the socket is local-user trust, tighten with a peer credential.
+ */
+export function refuseAgentManage(sessionIdOrName, rawArg, opts, operator, now = Date.now()) {
+    if (operator)
+        return null;
+    const arg = rawArg.trim().toLowerCase();
+    const resolved = resolveSession(sessionIdOrName);
+    const cur = resolved ? state[resolved.sessionId]?.shift?.until : undefined;
+    const names = [sessionIdOrName, resolved?.name ?? ""];
+    const ending = /^(off|stop)$/.test(arg) ? "off" :
+        arg === "pause" ? "pause" :
+            /^shift\s+(off|stop|end|stand down)\b/.test(arg) ? "shift-off" : null;
+    if (ending)
+        return consumeToken(names, ending, now) ? null : AGENT_REFUSAL;
+    const shift = arg.match(/^shift\b\s*([\s\S]*)$/);
+    const next = shift ? now + parseShift(shift[1], new Date(now)).hours * 3_600_000 : opts.until ? parseUntilSpec(opts.until, new Date(now)) : null;
+    // Minute precision: the same clock time is not a shortening because of float/ms drift.
+    const minute = (t) => Math.floor(t / 60_000);
+    return next !== null && cur !== undefined && cur > now && minute(next) < minute(cur) ? AGENT_REFUSAL : null;
+}
+/** "08:00", "until 8pm", "8h", "90m" → epoch ms; null when it reads as none of these. */
+export function parseUntilSpec(spec, now = new Date()) {
+    const t = spec.trim().toLowerCase();
+    if (/^\d{1,2}(:\d{2})?\s*(am|pm)?$/.test(t))
+        return parseUntilClock(`until ${t}`, now);
+    if (/^(until|till|til)\s/.test(t))
+        return parseUntilClock(t, now);
+    const d = t.match(/^(?:for\s+)?(\d+(?:[.,]\d+)?)\s*(h|hr|hrs|hours?|m|min|mins|minutes?)$/);
+    if (!d)
+        return null;
+    const n = Number(d[1].replace(",", "."));
+    const ms = n * (/^h/.test(d[2]) ? 3_600_000 : 60_000);
+    return now.getTime() + Math.min(ms, SHIFT_MAX_HOURS * 3_600_000);
+}
+const NUDGE_EVERY_MIN = 5;
+const NUDGE_EVERY_MAX = 480;
+/** Minutes between idle nudges: 30, "30", "30m", "1h". Null outside 5..480. */
+export function parseEveryMin(v) {
+    const t = String(v ?? "").trim().toLowerCase();
+    const m = t.match(/^(\d+(?:\.\d+)?)\s*(h|hr|hrs|hours?|m|min|mins|minutes?)?$/);
+    if (!m)
+        return null;
+    const n = Math.round(Number(m[1]) * (m[2] && m[2].startsWith("h") ? 60 : 1));
+    return n >= NUDGE_EVERY_MIN && n <= NUDGE_EVERY_MAX ? n : null;
+}
+/** When the next nudge (with `every`) or the ~46-50 min lapse re-arm falls due. */
+export function nextDueAt(m) {
+    if (m.paused)
+        return null;
+    if (m.nudgeEveryMin) {
+        return Math.max(m.lastChangeAt, m.lastNudgeAt ?? 0, m.lastRearmAt) + m.nudgeEveryMin * 60_000;
+    }
+    return m.lastRearmAt + GOAL_MAX_AGE_MS;
+}
+/**
+ * Should a short "continue the goal" line be typed now? Only for a session
+ * with an `every` interval whose goal marker is still shown (a missing marker
+ * is the full re-arm, handled by reasonToArm), idle for that long, with an
+ * EMPTY input line — text there is somebody's, same rule as pointer-guard.
+ * The caller has already ruled out a busy session.
+ */
+export function nudgeDue(m, content, now) {
+    if (!m.nudgeEveryMin || m.paused || shiftOver(m, now))
+        return false;
+    if (!GOAL_ACTIVE.test(content))
+        return false;
+    if (promptUnsentText(content) !== null)
+        return false;
+    if (QUEUED_HINT_RE.test(content.split("\n").slice(-8).join("\n")))
+        return false;
+    const due = nextDueAt(m);
+    return due !== null && now >= due;
+}
+export const NUDGE_TEXT = "Continue working toward your standing goal.";
+/**
+ * The API-retry banner, seen live 2026-10-17 14:50:
+ *
+ *   Goal still active · the API was unavailable or the connection dropped ·
+ *   retrying in 1 min (1/3) · send a message to retry now
+ *
+ * Claude Code retries three times, then gives up — and the goal sits frozen
+ * over a session that is not working but sleeping between retries. The banner
+ * itself offers the way out — any message retries now — so the manager takes
+ * it: one minimal continue per minute, for as long as the banner lasts,
+ * deterministically and with no cap, because a stretch of API trouble can
+ * outlast any count.
+ */
+export const API_RETRY = /the API was unavailable or the connection dropped|retrying in \d+ min \(\d+\/3\)/;
+/** At most one retry-breaking message per minute while the banner persists. */
+export const API_RETRY_EVERY_MS = 60_000;
+/** The history note about the banner dedups; the nudge itself is 1/60s, not the note. */
+const API_RETRY_NOTE_EVERY_MS = 5 * 60_000;
+export const API_RETRY_TEXT = "Continue now — the API is back. Pick the turn up where it dropped.";
+/**
+ * Type the retry-breaking continue when this pane shows the banner and a
+ * minute has passed since the last one. Never over text sitting unsent on the
+ * input line (skip silently; the next tick tries again), never while paused,
+ * never past a shift's end — the banner is not a reason to restart a
+ * stood-down session. Returns true when a line went out.
+ *
+ * The tick calls it before the busy gate: the retry wait IS the busy state
+ * here, and typing mid-turn is safe because the line queues at the turn
+ * boundary. `type` is injectable so the caller's exact behavior is testable
+ * without a terminal; the tick passes nothing and gets the real one.
+ */
+export function apiRetryNudge(m, content, now, type = typeIntoSession) {
+    if (m.paused || shiftOver(m, now))
+        return false;
+    if (!API_RETRY.test(content))
+        return false;
+    if (promptUnsentText(content) !== null)
+        return false;
+    if (now - (m.lastApiRetryAt ?? 0) < API_RETRY_EVERY_MS)
+        return false;
+    type(m.sessionId, API_RETRY_TEXT);
+    m.lastApiRetryAt = now;
+    if (!m.apiRetryNotedAt || now - m.apiRetryNotedAt >= API_RETRY_NOTE_EVERY_MS) {
+        note(m, "API-retry banner on the pane — typed a continue to break the retry wait (1/min while it lasts)");
+        m.apiRetryNotedAt = now;
+    }
+    return true;
+}
+const hhmm = (t) => {
+    const d = new Date(t);
+    return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+};
+/** One block for every managed session: name, goal, until, next due, context, last handover, state. */
+export function statusLines(sessions, now, kOf = () => null) {
+    if (sessions.length === 0)
+        return ["no sessions are being managed"];
+    return sessions.map((m) => {
+        const goal = oneLine(m.objective);
+        const due = nextDueAt(m);
+        const k = kOf(m);
+        const pct = k !== null ? Math.round((k / (m.contextWindowK ?? 1000)) * 100) : null;
+        const state = m.paused ? "paused" : m.shift ? (m.shift.plain ? "supervised" : "shift") : "on";
+        return [
+            m.name,
+            `goal: ${goal.length > 80 ? `${goal.slice(0, 79)}…` : goal}`,
+            `until: ${m.shift ? hhmm(m.shift.until) : "-"}`,
+            `next ${m.nudgeEveryMin ? "nudge" : "arm"}: ${due === null ? "-" : due <= now ? "due" : `in ${Math.round((due - now) / 60_000)}m`}`,
+            `ctx: ${k !== null ? `${pct}% ${k}k` : "?"}`,
+            `handover: ${m.handoverDoneAt ? hhmm(m.handoverDoneAt) : "-"}`,
+            state,
+        ].join(" | ");
+    });
+}
 /**
  * The standing objective for a shift, written once here instead of by hand
  * every night. It says what to work on and what "done" means; how to work is
@@ -2011,12 +2412,23 @@ export function briefSlug(m) {
  * The line typed at the session: `/goal` plus a pointer to the brief, plus as
  * much of the objective's first words as fits. Never longer than `max`.
  */
-export function buildGoalLine(briefPath, objective, max = GOAL_LINE_MAX_CHARS) {
-    const head = `/goal Follow ${briefPath} until done`;
+export function buildGoalLine(briefPath, objective, until = null, max = GOAL_LINE_MAX_CHARS) {
+    const head = `/goal ${noDoneStatePrefix(until)} Follow ${briefPath}`;
     const room = max - head.length - 2;
     const words = oneLine(objective);
     return room >= 20 && words ? `${head}: ${truncateAtWord(words, room)}` : head;
 }
+/**
+ * Opens EVERY armed goal, so Claude Code's evaluator has no done-state to judge
+ * met: a goal that names one ("until the fix is in build N") is cleared the
+ * moment the session says it is. Only the operator ends a goal. Never dropped
+ * to fit the line — the objective is shortened first.
+ */
+export function noDoneStatePrefix(until) {
+    return until !== null
+        ? `Keep working until ${hhmm(until)}. There is no earlier done-state. Only the operator ends this goal.`
+        : "Keep working. There is no done-state. Only the operator ends this goal.";
+}
 /** Everything that does not fit on the typed line, as the file it points to. */
 export function buildBrief(parts) {
     const sections = [];
@@ -2060,12 +2472,12 @@ function goalText(m) {
         objective: m.objective,
         agentish: AG2_SPEC,
         rulesSource: rules ? standingRulesSource() : "",
-        shiftRules: m.shift && m.objective !== shift ? shift : "",
+        shiftRules: m.shift && !m.shift.plain && m.objective !== shift ? shift : "",
         hands,
         pending: m.pending,
     }), { mode: 0o600 });
     chmodSync(path, 0o600);
-    return { text: buildGoalLine(foldHome(path), m.objective) };
+    return { text: buildGoalLine(foldHome(path), m.objective, m.shift?.until ?? null) };
 }
 /**
  * Did it arm? Within a bounded wait the pane must show the goal marker with an
@@ -2079,7 +2491,7 @@ export async function confirmArmed(typed, deps, waits = 5, waitMs = 2_000) {
     let unsent = null;
     for (let i = 0; i < waits; i++) {
         await deps.sleep(waitMs);
-        const pane = deps.readPane();
+        const pane = await deps.readPane();
         unsent = promptUnsentText(pane);
         if (GOAL_ACTIVE.test(pane) && !unsent)
             return true;
@@ -2088,6 +2500,15 @@ export async function confirmArmed(typed, deps, waits = 5, waitMs = 2_000) {
         deps.clearInput();
     return false;
 }
+/** readPane for async callers (tick, arm): the iTerm read does not block the event loop. */
+async function readPaneAsync(sessionId, opts = {}) {
+    try {
+        return (await readSessionContentAsync(sessionId, 60, opts))?.content ?? "";
+    }
+    catch {
+        return "";
+    }
+}
 function readPane(sessionId, opts = {}) {
     try {
         return readSessionContent(sessionId, 60, opts)?.content ?? "";
@@ -2099,7 +2520,60 @@ function readPane(sessionId, opts = {}) {
 async function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
-async function arm(m, reason) {
+/**
+ * Read the input line back after a paste, polling while it is still empty: under
+ * load the terminal has not rendered the paste after a fixed 300 ms. Returns as
+ * soon as the line is non-empty (the caller decides match vs mangled), or the
+ * empty line once the bound is spent. Never decides anything itself.
+ */
+export async function readBackTyped(deps) {
+    const delays = deps.delaysMs ?? [300, 300, 500, 800, 1_000, 1_000, 1_100]; // ~5 s
+    let waitedMs = 0;
+    let line = "";
+    for (const d of delays) {
+        await deps.sleep(d);
+        waitedMs += d;
+        line = await deps.read();
+        if (line)
+            break;
+    }
+    return { line, waitedMs };
+}
+/**
+ * Wrap `run` so a call made while the previous one is still pending is skipped
+ * (onSkip) instead of started. The tick yields to the event loop on every pane
+ * read, so under load one outlasts TICK_MS and the next interval would arm the
+ * same session a second time.
+ */
+export function nonOverlapping(run, onSkip) {
+    let running = false;
+    return async () => {
+        if (running)
+            return onSkip();
+        running = true;
+        try {
+            await run();
+        }
+        finally {
+            running = false;
+        }
+    };
+}
+/** Sessions with an arm() in flight; a second arm for the same id is refused. */
+const arming = new Set();
+/** Run fn unless `id` is already in `busy`; returns undefined when refused. */
+export async function tryExclusive(busy, id, fn) {
+    if (busy.has(id))
+        return undefined;
+    busy.add(id);
+    try {
+        return await fn();
+    }
+    finally {
+        busy.delete(id);
+    }
+}
+export async function arm(m, reason) {
     const { text } = goalText(m);
     /**
      * NEVER TYPE A GOAL INTO A BARE SHELL.
@@ -2121,15 +2595,15 @@ async function arm(m, reason) {
      * the thing we are managing is gone, and the right move is to say so and
      * stop, not to keep typing into whatever is there now.
      */
-    const live = readSessionContent(m.sessionId, 5);
+    const live = await readSessionContentAsync(m.sessionId, 5);
     if (!live) {
         note(m, "the session could not be read — not typing anything");
-        return false;
+        return "failed";
     }
     if (live.atPrompt && !isClaudePane(live.name)) {
         m.paused = true;
         notify(m, "PAUSED — that pane is at a shell prompt, so the session has exited. Not typing a goal into a shell. `resume` once it is back.");
-        return false;
+        return "failed";
     }
     /**
      * TEXT ON THE INPUT LINE — READ BACK FIRST, NEVER DESTROY LIVE INPUT.
@@ -2146,11 +2620,14 @@ async function arm(m, reason) {
      * SKIPPED and retried next tick — never cleared, never typed over —
      * unless the IDENTICAL text has sat there for GHOST_TICKS consecutive
      * ticks (2 minutes) while the session is idle, which is inputLineDecision's
-     * job to decide. Skips still count toward armFails/armFailStreak below, so
-     * a line occupied for minutes still reaches blockedReason's operator alert
-     * (with a screenshot) — the daemon does not stall silently either way.
+     * job to decide. A skip is NOT a failure: it counts toward nothing (on
+     * 2026-10-17 14:42 the operator typing while a demanded arm waited was
+     * counted as arm failures, crossed the cap, and the arm was never even
+     * typed — see test/manage-arm-skip.test.ts). The skip says so in the log at
+     * most once per 5 minutes; a DEMANDED arm held this way says so loudly, and
+     * once.
      */
-    const onLine = promptUnsentText(readPane(m.sessionId));
+    const onLine = promptUnsentText(await readPaneAsync(m.sessionId));
     const armIdleMs = Math.max(0, Date.now() - m.lastChangeAt);
     const armIdle = armIdleMs >= HANDOVER_IDLE_FLOOR_MS;
     const prevLine = inputLineTracking.get(m.sessionId);
@@ -2161,8 +2638,23 @@ async function arm(m, reason) {
         inputLineTracking.delete(m.sessionId);
     const lineDecision = inputLineDecision({ text: onLine ?? "", sameForTicks, idle: armIdle, idleMs: armIdleMs });
     if (lineDecision.action === "skip") {
-        note(m, `arm deferred: input line holds '${onLine}' (unsent for ${sameForTicks} tick${sameForTicks === 1 ? "" : "s"}, idle ${Math.round(armIdleMs / 1000)}s)`);
-        return false;
+        if (m.lastRearmAt !== 0) {
+            delete m.forcedArmHoldNotedAt;
+            if (!m.armSkipNotedAt || Date.now() - m.armSkipNotedAt >= 5 * 60_000) {
+                note(m, `arm deferred: input line holds '${onLine}' (unsent for ${sameForTicks} tick${sameForTicks === 1 ? "" : "s"}, idle ${Math.round(armIdleMs / 1000)}s)`);
+                m.armSkipNotedAt = Date.now();
+            }
+        }
+        else {
+            // The operator demanded this arm; what is holding it is their own
+            // unsent line. Say so, once, where it will be seen.
+            if (!m.forcedArmHoldNotedAt) {
+                notify(m, `a demanded arm (${reason}) is NOT being typed: the input line holds the operator's own unsent text ` +
+                    `("${(onLine ?? "").slice(0, 60)}") — clear or send that line to let the arm through; it is not typed over`);
+                m.forcedArmHoldNotedAt = Date.now();
+            }
+        }
+        return "skipped";
     }
     if (lineDecision.action === "clear-then-type") {
         note(m, lineDecision.logCleared ?? "clearing persistent input-line text before typing");
@@ -2186,37 +2678,97 @@ async function arm(m, reason) {
     //      (observed 2026-09-13), and arm() is otherwise fine typing into a
     //      busy session (the goal text below queues harmlessly behind it) —
     //      it is specifically the escape sequence that is not safe there.
-    if (armIdle && needsVimEscape(readPane(m.sessionId))) {
+    if (armIdle && needsVimEscape(await readPaneAsync(m.sessionId))) {
         escapeInputMode(m.sessionId);
     }
     if (!pasteTextIntoSession(m.sessionId, text)) {
         note(m, `could not type into the session (${reason}) — will retry`);
-        return false;
+        return "failed";
     }
-    await sleep(300); // let the pane catch up before reading it back
-    const echoedLine = promptUnsentText(readPane(m.sessionId, { fresh: true })) ?? "";
+    const { line: echoedLine, waitedMs } = await readBackTyped({
+        read: async () => promptUnsentText(await readPaneAsync(m.sessionId, { fresh: true })) ?? "",
+        sleep,
+    });
     if (!typedLineMatches(echoedLine, text)) {
         sendControlU(m.sessionId);
-        note(m, `arm aborted: line read back as "${echoedLine.slice(0, 60)}" not "${text.slice(0, 60)}"`);
-        return false;
+        await sleep(300);
+        const left = promptUnsentText(await readPaneAsync(m.sessionId, { fresh: true })) ?? "";
+        note(m, `arm aborted: after ${waitedMs}ms line read back as "${echoedLine.slice(0, 60)}" not "${text.slice(0, 60)}"; after Ctrl-U the input ${left ? `still holds ${left.length} chars ("${left.slice(0, 60)}")` : "is empty"}`);
+        return "failed";
     }
     sendEnterKey(m.sessionId);
     // Typed is not sent, and sent is not received.
     const landed = await confirmArmed(text, {
-        readPane: () => readPane(m.sessionId, { fresh: true }),
+        readPane: () => readPaneAsync(m.sessionId, { fresh: true }),
         sleep,
         clearInput: () => sendControlU(m.sessionId),
     });
     if (landed) {
         m.lastRearmAt = Date.now();
+        delete m.forcedArmHoldNotedAt;
         const carried = m.pending.length;
         m.pending = [];
         armingsSinceReport.set(m.sessionId, (armingsSinceReport.get(m.sessionId) ?? 0) + 1);
         note(m, `armed: ${reason}${carried ? ` (carrying ${carried} operator instruction${carried > 1 ? "s" : ""})` : ""}`);
-        return true;
+        return "armed";
     }
     notify(m, `typed but the goal never took (no active marker, or the line stayed in the input) — input cleared, treating as NOT armed (${reason})`);
-    return false;
+    return "failed";
+}
+/**
+ * The book-keeping one arm attempt's outcome earns, shared by every caller
+ * that retries on the tick.
+ *
+ * ONLY a "failed" counts. A skip is not here because it is not a fault: the
+ * guard that declined (the operator's own text on the input line) is doing
+ * its job, and the demand — or the lapse — is still pending on the next tick.
+ * Counting skips is the 2026-10-17 14:42 fault: three ticks of the operator
+ * typing crossed this cap, the cap consumed the forced-arm sentinel, and the
+ * manager went silent exactly when it had been told to act.
+ */
+export function applyArmResult(m, result, now) {
+    if (result === "armed") {
+        m.armFails = 0;
+        m.armFailStreak = 0;
+        delete m.stuckSince;
+        delete m.blockedSince;
+        delete m.blockedAlertedAt;
+        return;
+    }
+    if (result === "skipped")
+        return;
+    m.armFails = (m.armFails ?? 0) + 1;
+    m.armFailStreak = (m.armFailStreak ?? 0) + 1;
+    if (m.armFails >= ARM_ATTEMPTS) {
+        m.armFails = 0;
+        // The cap must not eat the sentinel: `lastRearmAt === 0` is a pending
+        // DEMANDED arm, and stamping it with `now` is what turned "arm NOW" into
+        // a 90-second cooldown and then a permanent mute on 2026-10-17 14:42.
+        // A pending forced arm survives the cap.
+        if (m.lastRearmAt !== 0)
+            m.lastRearmAt = now;
+        m.stuckSince ??= now;
+        // No operator push here. Pushing on every cap is the 144-alerts-overnight
+        // bug: this fires again every ~2-4 minutes for as long as arming keeps
+        // failing, and it is content-agnostic — it cannot tell "mid-turn, will
+        // clear itself" from "stuck on a modal for hours". The blocked check
+        // above owns the operator alert now: it has `armFailStreak`/`stuckSince`
+        // (which survive this reset) plus a static-pane confirmation, and its
+        // own BLOCKED_REALERT_MS dedup. This stays log-only.
+        note(m, `arming keeps failing (streak ${m.armFailStreak}) — holding off; the blocked check owns the operator alert now`);
+    }
+}
+/**
+ * Whether the stuck backoff — arming having crossed ARM_ATTEMPTS — may hold
+ * this session's arm back.
+ *
+ * A DEMANDED arm (`lastRearmAt === 0`) is never held by it. This is the other
+ * half of the 2026-10-17 14:42 fix: once the cap had marked the session stuck
+ * mid-demand, this gate muted every later tick, so the demanded arm was never
+ * even typed. A demand outranks a backoff it had no part in earning.
+ */
+export function stuckBackoffHolds(m) {
+    return m.stuckSince !== undefined && m.lastRearmAt !== 0;
 }
 /**
  * Why a managed session should be treated as BLOCKED — waiting on a human
@@ -2250,8 +2802,70 @@ export function blockedReason(m, content, now) {
     }
     return null;
 }
-function reasonToArm(m, content, now) {
-    if (m.paused)
+const STOPPED_REASON = "turn ended with nothing running — re-arming";
+const STOP_SETTLE_MS = 30_000;
+const STOP_NUDGE_COOLDOWN_MS = 3 * 60_000;
+// Status-line "N shells still running" / "N background tasks still running" and
+// the footer's "▶N" worker count — N must be > 0. The footer's "← N agents" and
+// "· N shells" (no "still running") are always-on, not work, and must not match.
+const BACKGROUND_RUNNING_RE = /\b[1-9]\d*\s+(?:background\s+)?(?:shells?|tasks?)\s+still\s+running\b|▶\s*[1-9]\d*/i;
+const LIVE_REGION_LINES = 20;
+/**
+ * The session's turn ended (last transcript record is an assistant turn with no
+ * tool call pending), settled for STOP_SETTLE_MS, the prompt is empty and
+ * nothing spins or runs in the background. Pure; never true over typed input.
+ */
+export function turnStoppedIdle(t, paneText, now) {
+    if (!t || t.working !== false || t.lastAt === null || now - t.lastAt < STOP_SETTLE_MS)
+        return false;
+    if (promptUnsentText(paneText) !== null)
+        return false;
+    const last = paneText.split("\n").slice(-LIVE_REGION_LINES).join("\n");
+    return !QUEUED_HINT_RE.test(last) && !SPINNER_RE.test(last) && !BACKGROUND_RUNNING_RE.test(last);
+}
+export const GOAL_GONE_REASON = "goal gone before until, re-armed";
+export const FORCED_ARM_REASON = "asked to arm now";
+/** How long one queued arm is awaited before another may be typed. */
+export const QUEUED_ARM_WAIT_MS = 10 * 60_000;
+export const GOAL_GONE_BUSY_REASON = "goal gone before until, re-armed (session busy, queued)";
+export const GOAL_FORCED_BUSY_REASON = "asked to arm now (session busy, queued)";
+/**
+ * An arm due while the session is mid-turn: Claude Code queues a submitted
+ * line and runs it at the next turn boundary, so arming now interrupts
+ * nothing. Same guards as the idle rule (not paused, until ahead, input line
+ * empty) plus at most one pending arm. Clears the pending mark once the marker
+ * is back or the turn is over.
+ *
+ * Forced arms too (`lastRearmAt === 0`, set by `now`, a new objective, a
+ * queued instruction, or supervise with a new goal), because a session arming
+ * ITSELF through the MCP tool is by definition mid-turn when it asks —
+ * waiting for an idle pane defers its request until a hard-working session
+ * happens to go quiet, which may be never. Unlike the goal-gone case the
+ * forced arm fires with the old marker still on screen: the point of the call
+ * is to replace that goal with the new text.
+ */
+export function busyGoalGoneReason(m, content, now, busy) {
+    if (!busy) {
+        delete m.queuedArmAt;
+        return null;
+    }
+    const forced = reasonToArm(m, content, now) === FORCED_ARM_REASON;
+    if (!forced && GOAL_ACTIVE.test(content)) {
+        delete m.queuedArmAt;
+        return null;
+    }
+    if (m.queuedArmAt !== undefined && now - m.queuedArmAt < QUEUED_ARM_WAIT_MS)
+        return null;
+    if (forced)
+        return GOAL_FORCED_BUSY_REASON;
+    return reasonToArm({ ...m, lastRearmAt: m.lastRearmAt || 1 }, content, now) === GOAL_GONE_REASON
+        ? GOAL_GONE_BUSY_REASON
+        : null;
+}
+/** A shift/supervision whose `until` has passed: nothing proactive is typed into the session any more. */
+export const shiftOver = (m, now) => !!m.shift && now >= m.shift.until;
+export function reasonToArm(m, content, now) {
+    if (m.paused || shiftOver(m, now))
         return null;
     if (OUT_OF_GOAL.some((re) => re.test(content)))
         return "the session reported its goal could not be achieved";
@@ -2260,10 +2874,15 @@ function reasonToArm(m, content, now) {
     // true of a number and nonsense about the world — the kind of line that costs
     // somebody ten minutes at three in the morning.
     if (m.lastRearmAt === 0)
-        return "asked to arm now";
+        return FORCED_ARM_REASON;
     const quietFor = Math.max(0, now - m.lastChangeAt);
     const armedFor = Math.max(0, now - m.lastRearmAt);
     const marker = GOAL_ACTIVE.test(content);
+    // The goal was cleared (the session's own doing, or the evaluator's) while the
+    // operator's stretch is still running: no lapse timer, re-arm on this tick.
+    // Paused is the operator's; an occupied input line is never typed over.
+    if (!marker && m.shift && m.shift.until > now && promptUnsentText(content) === null)
+        return GOAL_GONE_REASON;
     if (!marker && quietFor > NO_GOAL_GRACE_MS)
         return `no goal armed (idle ${Math.round(quietFor / 1000)}s)`;
     /**
@@ -2368,7 +2987,7 @@ async function tick() {
         }
     }
     for (const m of Object.values(state)) {
-        const content = readPane(m.sessionId);
+        const content = await readPaneAsync(m.sessionId);
         if (!content) {
             // A session that cannot be read is not necessarily gone; say so once per
             // tick rather than dropping it, because dropping it silently is how a
@@ -2388,13 +3007,17 @@ async function tick() {
         // it once per session per tick is the same reading at a fraction of the
         // cost.
         const tickTty = m.tty ?? snapshotTty(m.sessionId);
-        const tickPid = tickTty ? processReading(tickTty).pid : null;
-        const tickTranscript = tickPid ? transcriptReading(tickPid) : null;
-        const working = sessionIsWorking(tickTranscript, now);
+        const tickProc = tickTty ? processReading(tickTty) : null;
+        const tickPid = tickProc?.pid ?? null;
+        const tickUuid = tickProc?.uuid ?? (tickTty ? discoverLiveSessions().find((s) => s.id === m.sessionId)?.attachUuid : undefined);
+        const tickTranscript = tickPid ? transcriptReading(tickPid, tickUuid) : null;
+        // A turn that ended with nothing running is a stop, not work: the 2-minute
+        // "recent transcript" window must not hide it.
+        const stopped = turnStoppedIdle(tickTranscript, content, now);
+        const working = !stopped && sessionIsWorking(tickTranscript, now);
         const tickUsed = tickTranscript?.contextK ?? null;
-        const tickCwd = tickPid ? sessionCwd(tickPid) : null;
-        const tickDirCandidate = tickCwd ? join(homedir(), ".claude", "projects", tickCwd.replace(/\//g, "-")) : null;
-        const tickDir = tickDirCandidate && existsSync(tickDirCandidate) ? tickDirCandidate : null;
+        const tickDir = tickPid ? projectTranscriptDir(tickPid, tickUuid) : null;
+        const tickCwd = tickPid ? sessionProjectCwd(tickPid, tickUuid) : null;
         // Sample context for the fill-rate reading in `status`. Pushed only when
         // a real number is available — never a synthetic 0 for a tick where the
         // transcript could not be read, which would read as a session that
@@ -2812,10 +3435,12 @@ async function tick() {
             const grownBy = used !== null && m.handoverDoneK !== undefined ? used - m.handoverDoneK : null;
             if (decision.due) {
                 const notesDirExists = tickCwd ? existsSync(join(tickCwd, "Notes")) : false;
-                const usedDefault = !m.handoverFile;
-                const askedPath = m.handoverFile
-                    ? resolveHandoverPath(m.handoverFile)
-                    : (defaultHandoverTarget(tickCwd, notesDirExists) ?? undefined);
+                const target = pickHandoverTarget({
+                    handoverFile: m.handoverFile,
+                    sinkDescription: projectSinkDescription(tickCwd),
+                    defaultPath: defaultHandoverTarget(tickCwd, notesDirExists),
+                });
+                const askedPath = target.path;
                 m.handoverAskedAt = now;
                 m.handoverAskedPath = askedPath;
                 m.handoverWas = askedPath ? fileFingerprint(askedPath) : undefined;
@@ -2828,7 +3453,9 @@ async function tick() {
                     : "";
                 const whereClause = askedPath
                     ? `Update ${askedPath}. ${carry}`
-                    : `Write it to your project's handover file (its ## Continue section, or wherever this project's convention keeps that) — nothing was set or found automatically, so use your own judgement about where that lives here. `;
+                    : target.description
+                        ? `Update ${target.description}. `
+                        : `Write it to your project's handover file (its ## Continue section, or wherever this project's convention keeps that) — nothing was set or found automatically, so use your own judgement about where that lives here. `;
                 // Wording follows the band: IMMEDIATE has no time to spare and says
                 // so; REFRESH and a work-triggered WARM-UP both mean the session has
                 // already written one and this is about the work SINCE, not a repeat
@@ -2850,7 +3477,7 @@ async function tick() {
                 notify(m, `at ${used}k tokens (${decision.reason})` +
                     (grownBy !== null ? `, ${grownBy}k of new work since the last one` : "") +
                     ` — asked for a handover${m.clearAfterHandover ? " before rolling over" : " before it compacts"}` +
-                    (askedPath ? ` — target: ${askedPath}${usedDefault ? " (default — no handoverFile set)" : ""}` : " — no target resolved, asked without naming a path"));
+                    (target.source !== "none" ? ` — target (${target.source}): ${askedPath ?? target.description}` : " — no target resolved, asked without naming a path"));
                 // The idle age that justified typing into this session now — the
                 // un-gated ask reaches every managed session, not just the one
                 // opted-in session it used to, so the evidence for "this was a safe
@@ -2887,6 +3514,33 @@ async function tick() {
          * from when it would otherwise fire — it never suppresses one, since a
          * genuinely stuck session goes quiet on the transcript too.
          */
+        /**
+         * API-RETRY KEEP-ALIVE — ahead of every gate below that continues on a
+         * busy or blocked pane, because the retry wait IS the busy state here and
+         * waiting it out loses the stretch: Claude Code retries three times and
+         * gives up, leaving the goal frozen over a session that is only sleeping
+         * between its own retries. The banner coexists with "Goal still active",
+         * so this never re-arms — it only breaks the retry wait.
+         */
+        if (apiRetryNudge(m, content, now)) {
+            dirty = true;
+            continue;
+        }
+        // Goal gone — or a forced arm (now / supervise with a new goal, asked by a
+        // session that is itself mid-turn) — mid-turn: queue the arm behind the
+        // turn instead of waiting for an idle tick.
+        const queuedReason = busyGoalGoneReason(m, content, now, working && !paneLooksIdle(content, now - m.lastChangeAt));
+        if (queuedReason && now - m.lastRearmAt >= REARM_COOLDOWN_MS) {
+            // Pending whether or not the read-back saw it land: a queued line is invisible until the turn ends.
+            m.queuedArmAt = now;
+            const queued = await tryExclusive(arming, m.sessionId, () => arm(m, queuedReason));
+            if (queued === undefined)
+                delete m.queuedArmAt;
+            else if (queued === "failed")
+                note(m, `${queuedReason} — not confirmed, waiting for the turn to end or the marker`);
+            dirty = true;
+            continue;
+        }
         if (!m.paused && lease) {
             if (working) {
                 const hadState = m.blockedSince !== undefined || m.blockedAlertedAt !== undefined || m.stuckSince !== undefined;
@@ -2949,13 +3603,43 @@ async function tick() {
         // REARM_COOLDOWN_MS. This is what actually fixes the overnight bug: the
         // old code kept re-arming (and re-spamming) forever because each retype
         // reset lastChangeAt and the freeze detector never got a quiet window.
-        if (m.stuckSince !== undefined)
+        //
+        // But a DEMANDED arm is never held here (2026-10-17 14:42): the cap had
+        // marked the session stuck while the operator was mid-demand, and this
+        // gate then muted every tick after it — the demanded arm was never even
+        // typed. A demand outranks a backoff it had no part in earning.
+        if (stuckBackoffHolds(m))
             continue;
         if (now - m.lastRearmAt < REARM_COOLDOWN_MS)
             continue;
-        const reason = reasonToArm(m, content, now);
-        if (!reason)
+        let reason = reasonToArm(m, content, now);
+        const over = shiftOver(m, now);
+        if (over && m.shift && !m.shift.lapseNoted) {
+            m.shift.lapseNoted = true;
+            note(m, "until passed — no more nudges/arms");
+            dirty = true;
+        }
+        if (stopped && !m.paused && !over && (!reason || reason.startsWith("no goal armed")) && !GOAL_ACTIVE.test(content)) {
+            reason = STOPPED_REASON;
+        }
+        if (!reason && stopped && !m.paused && !over && now - (m.lastNudgeAt ?? 0) >= STOP_NUDGE_COOLDOWN_MS) {
+            // Marker still up but the turn ended on nothing: nudge now, not at the lapse timer.
+            typeIntoSession(m.sessionId, NUDGE_TEXT);
+            m.lastNudgeAt = now;
+            note(m, `${STOPPED_REASON.replace("re-arming", "nudged to continue")}`);
+            dirty = true;
             continue;
+        }
+        if (!reason) {
+            // Idle at an empty prompt past the `every` interval: a short nudge, not the full goal.
+            if (nudgeDue(m, content, now)) {
+                typeIntoSession(m.sessionId, NUDGE_TEXT);
+                m.lastNudgeAt = now;
+                note(m, `idle ${m.nudgeEveryMin}+ min at an empty prompt — nudged to continue`);
+                dirty = true;
+            }
+            continue;
+        }
         /**
          * A GOAL THAT CANNOT BE CONFIRMED IS NOT RETRIED FOREVER.
          *
@@ -2972,32 +3656,19 @@ async function tick() {
          * ordinary rules — the session is still managed, and the next genuine
          * lapse arms it — and the operator is told, because a manager that has
          * given up on delivering a goal is the one thing it must never do quietly.
+         *
+         * Counting is for GENUINE FAILURES only. On 2026-10-17 14:42 the count
+         * also took guard skips: the operator, mid-demand ("arm NOW"), was typing
+         * into the pane, three occupied-line ticks crossed the cap, the cap
+         * consumed the forced-arm sentinel, and the manager — told to act — never
+         * typed at all. A guard declining is the system working, not the attempt
+         * failing.
          */
-        const armed = await arm(m, reason);
+        const armed = await tryExclusive(arming, m.sessionId, () => arm(m, reason));
+        if (armed === undefined)
+            continue; // another arm for this session is in flight
         dirty = true;
-        if (armed) {
-            m.armFails = 0;
-            m.armFailStreak = 0;
-            delete m.stuckSince;
-            delete m.blockedSince;
-            delete m.blockedAlertedAt;
-            continue;
-        }
-        m.armFails = (m.armFails ?? 0) + 1;
-        m.armFailStreak = (m.armFailStreak ?? 0) + 1;
-        if (m.armFails >= ARM_ATTEMPTS) {
-            m.armFails = 0;
-            m.lastRearmAt = now;
-            m.stuckSince ??= now;
-            // No operator push here. Pushing on every cap is the 144-alerts-overnight
-            // bug: this fires again every ~2-4 minutes for as long as arming keeps
-            // failing, and it is content-agnostic — it cannot tell "mid-turn, will
-            // clear itself" from "stuck on a modal for hours". The blocked check
-            // above owns the operator alert now: it has `armFailStreak`/`stuckSince`
-            // (which survive this reset) plus a static-pane confirmation, and its
-            // own BLOCKED_REALERT_MS dedup. This stays log-only.
-            note(m, `arming keeps failing (streak ${m.armFailStreak}) — holding off; the blocked check owns the operator alert now`);
-        }
+        applyArmResult(m, armed, now);
     }
     if (dirty)
         saveState(state);
@@ -3012,8 +3683,17 @@ export function startManagerLoop() {
     const n = Object.keys(state).length;
     if (n)
         log(`[manage] resuming ${n} managed session${n > 1 ? "s" : ""}`);
+    let skipLogged = false;
+    const guarded = nonOverlapping(tick, () => {
+        if (skipLogged)
+            return;
+        skipLogged = true;
+        log("[manage] tick still running — skipping overlapping tick");
+    });
     timer = setInterval(() => {
-        void tick().catch((e) => log(`[manage] tick failed — ${e.message}`));
+        void guarded()
+            .then(() => { skipLogged = false; })
+            .catch((e) => log(`[manage] tick failed — ${e.message}`));
     }, TICK_MS);
     timer.unref?.();
 }
@@ -3044,8 +3724,13 @@ export function stopManaging(s, sessionId, name) {
  * `/manage pause|resume` stop arming without forgetting the objective
  * `/manage now`          arm immediately, whatever the signals say
  */
-export async function handleManage(sessionIdOrName, rawArg) {
+export async function handleManage(sessionIdOrName, rawArg, opts = {}) {
     const arg = (rawArg ?? "").trim();
+    // Every managed session in one block — before any peer forwarding or
+    // single-session resolution, since "all" names no session.
+    if (sessionIdOrName.trim().toLowerCase() === "all" && (!arg || arg.toLowerCase() === "status")) {
+        return { ok: true, message: statusLines(Object.values(state), Date.now(), contextK).join("\n") };
+    }
     /**
      * `machine/session` is managed by that machine's own hub.
      *
@@ -3069,6 +3754,36 @@ export async function handleManage(sessionIdOrName, rawArg) {
     if (!resolved)
         return { ok: false, message: `no live session matches "${sessionIdOrName}"` };
     const { sessionId, name } = resolved;
+    /**
+     * supervise — a session puts itself under the manager in one call:
+     * {goal, until, every}. goal = standing objective, until = end of the
+     * stretch (clock time or duration), every = idle-nudge interval in minutes.
+     */
+    if (arg.toLowerCase() === "supervise") {
+        const until = opts.until ? parseUntilSpec(opts.until) : null;
+        const every = opts.every !== undefined && opts.every !== "" ? parseEveryMin(opts.every) : null;
+        if (opts.until && until === null)
+            return { ok: false, message: `cannot read until="${opts.until}" — use a clock time (08:00) or a duration (8h, 90m)` };
+        if (opts.every !== undefined && opts.every !== "" && every === null)
+            return { ok: false, message: `every="${opts.every}" must be ${NUDGE_EVERY_MIN}-${NUDGE_EVERY_MAX} minutes` };
+        const goal = (opts.goal ?? "").trim();
+        if (!state[sessionId]) {
+            if (!goal)
+                return { ok: false, message: `${name} is not being managed — supervise needs a goal` };
+            const started = await handleManage(sessionId, `start ${goal}`);
+            if (!started.ok)
+                return started;
+        }
+        const m = state[sessionId];
+        applySupervise(m, goal, until, every);
+        saveState(state);
+        startManagerLoop();
+        return {
+            ok: true,
+            managed: true,
+            message: `${name} is supervised${until !== null ? ` until ${hhmm(until)}` : ""}${m.nudgeEveryMin ? `, nudged after ${m.nudgeEveryMin} min idle` : ""}.\n  ${statusLines([m], Date.now(), contextK)[0]}`,
+        };
+    }
     const existing = state[sessionId];
     const word = arg.toLowerCase();
     // help — the grammar, from the thing that implements it.
@@ -3118,7 +3833,8 @@ export async function handleManage(sessionIdOrName, rawArg) {
                 `                a bounded stretch of autonomous work on the tracker's open\n` +
                 `                issues: objective, screen decision, expiry and arming in one\n` +
                 `                sentence. \`shift off\` stands it down without killing it\n` +
-                `  now           arm immediately, whatever the signals say\n` +
+                `  now           arm immediately, whatever the signals say — safe mid-turn,\n` +
+                `                the /goal line queues behind a running turn\n` +
                 `  pause         stop arming, keep the objective\n` +
                 `  resume        start arming again\n` +
                 `  off           stop managing entirely\n` +
@@ -3331,7 +4047,7 @@ export async function handleManage(sessionIdOrName, rawArg) {
     const setMatch = arg.match(/^(?:set|objective|replace|start)\s+([\s\S]+)$/i);
     if (setMatch && existing) {
         const before = existing.objective;
-        existing.objective = setMatch[1].trim();
+        setObjective(existing, setMatch[1].trim());
         // Notes written against the old objective may not make sense against the
         // new one; say so rather than silently carrying them over.
         const dropped = existing.pending.length;
@@ -3363,7 +4079,7 @@ export async function handleManage(sessionIdOrName, rawArg) {
     const addMatch = arg.match(/^(?:add|also|append|extend)\s+([\s\S]+)$/i);
     if (addMatch && existing) {
         const extra = addMatch[1].trim();
-        existing.objective = `${existing.objective} Also: ${extra}`;
+        setObjective(existing, `${existing.objective} Also: ${extra}`);
         note(existing, `objective extended: ${extra.slice(0, 80)}`);
         saveState(state);
         return {
@@ -3546,7 +4262,7 @@ export async function handleManage(sessionIdOrName, rawArg) {
     }
     /**
      * handover-at <k> — this session's own warm-up margin, overriding the
-     * default 100k.
+     * default 50k.
      *
      * A fixed FRACTION of a fixed window cannot be right for every session —
      * that was tried (0.82 of a 1000k window) and the ground moved under it:
@@ -3617,9 +4333,12 @@ export async function handleManage(sessionIdOrName, rawArg) {
             objective,
             pending: [],
             history: [],
-            // Give the session the benefit of the grace period rather than arming
-            // on top of whatever it is doing at the moment the operator types this.
-            lastRearmAt: Date.now(),
+            // EVERY ask for arming is now (2026-10-17 14:48). The grace period this
+            // line once gave — don't arm on top of whatever the session is doing as
+            // the operator types — predates safe mid-turn queuing: a queued arm
+            // lands at the turn boundary and interrupts nothing, so its reason is
+            // gone, and 0 arms on the very next tick.
+            lastRearmAt: 0,
             lastChangeAt: Date.now(),
             lastHash: hash(readPane(sessionId)),
             tty: snapshotTty(sessionId),
@@ -3645,7 +4364,7 @@ export async function handleManage(sessionIdOrName, rawArg) {
         return { ok: true, managed: true, message: `${name} will be armed on the next tick` };
     }
     const instruction = arg.match(/^instruct\s+([\s\S]+)$/i)?.[1].trim() ?? arg;
-    existing.pending.push(instruction);
+    queueInstruction(existing, instruction);
     note(existing, `operator: ${instruction.slice(0, 80)}`);
     saveState(state);
     return {