team 0.0.1 → 0.1.1

package/dist/watch/pass.d.ts

@@ -0,0 +1,42 @@
+import { type Seen } from '../budgets/readings.ts';
+import type { CheckOutcome } from '../budgets/run.ts';
+import type { TeamFile } from '../file/types.ts';
+import type { SessionState } from '../state.ts';
+import type { Live } from '../status/compare.ts';
+import { type Report, type SeatCheck, type SeatHistory, type TeamCheck } from './check.ts';
+import type { Machine } from './machine.ts';
+export type Memory = {
+    history: Record<string, SeatHistory>;
+    slots: Record<string, unknown>;
+    active: Set<string>;
+    pending: string[];
+    pendingSince: number | null;
+};
+export declare function newMemory(): Memory;
+export type { Report } from './check.ts';
+export declare const NUDGE_TEXT = "Team watch: reports are waiting in .agents/team.log";
+export type PassResult = {
+    reports: Report[];
+    nudge: {
+        pane: string;
+        text: string;
+        pending: string[];
+    } | null;
+    fallback: string | null;
+    readings: Seen[];
+};
+export declare const SEAT_CHECKS: SeatCheck[];
+export declare const TEAM_CHECKS: TeamCheck[];
+export type PassInput = {
+    team: TeamFile;
+    state: SessionState;
+    live: Live;
+    machine: Machine;
+    now: number;
+    memory: Memory;
+    approval?: string[] | null;
+    watch?: TeamFile['watch'];
+    outcomes?: readonly CheckOutcome[];
+    budgets?: TeamFile['budgets'];
+};
+export declare function pass({ team, state, live, machine, now, memory, approval, watch, outcomes, budgets, }: PassInput): PassResult;

package/dist/watch/pass.js

@@ -0,0 +1,242 @@
+// One pass of the watch: the core. It builds one observation per seat before any check runs,
+// runs the registered checks in the order it owns, applies the report-once rule, and dials the
+// nudge. A check never reads herdr, a screen or the file itself — only the observation it is
+// handed (RFC 0002 § 4.2).
+import { WATCH_CHECKS_CHANGED } from "../approve/fingerprint.js";
+import { observe, recall } from "../budgets/readings.js";
+import { quotaFor } from "../profiles/profile.js";
+import { figuresOf } from "../profiles/quota.js";
+import { seatModel } from "../status/statusline.js";
+import { ALWAYS_ON, } from "./check.js";
+import { minutes } from "./check.js";
+import { attention } from "./checks/attention.js";
+import { approval } from "./checks/approval.js";
+import { budget } from "./checks/budget.js";
+import { disk } from "./checks/disk.js";
+import { extra } from "./checks/extra.js";
+import { idle } from "./checks/idle.js";
+import { load } from "./checks/load.js";
+import { memory as memoryCheck } from "./checks/memory.js";
+import { missing } from "./checks/missing.js";
+import { modelDrift } from "./checks/model-drift.js";
+import { swapFree } from "./checks/swap-free.js";
+import { swapGrowth } from "./checks/swap-growth.js";
+import { teamIdle } from "./checks/team-idle.js";
+import { unsent } from "./checks/unsent.js";
+import { readScreen, statusRow } from "./screen.js";
+export function newMemory() {
+    return { history: {}, slots: {}, active: new Set(), pending: [], pendingSince: null };
+}
+// The one line the watch types into the operator's pane. Fixed, and free of report text: a dialog
+// can open between the screen read and the typing, and a digit in the line would answer it. The
+// reports go to the log and to the desktop notification; the line only says where they are.
+export const NUDGE_TEXT = 'Team watch: reports are waiting in .agents/team.log';
+// The seat checks, in the order their reports land in the log; the team checks, after them. The
+// order is the core's: a seat's wrong model is reported before its permission prompt, and every
+// seat before the team. Disabling a check in the file's `watch.checks` takes it out of the run,
+// except the four that can't be turned off.
+export const SEAT_CHECKS = [missing, modelDrift, attention, unsent, idle];
+export const TEAM_CHECKS = [extra, teamIdle, approval, load, memoryCheck, disk, swapFree, swapGrowth, budget];
+// The one exclusive reading of a seat's screen and herdr status. herdr can report a seat at a
+// permission prompt as idle, so the screen decides first.
+function attentionOf(screen, status, quiet) {
+    if (screen.kind === 'permission' || screen.kind === 'trust')
+        return 'permission';
+    if (screen.kind === 'question')
+        return 'question';
+    if (status === 'blocked')
+        return 'blocked';
+    if (!quiet && status !== 'working')
+        return 'unknown';
+    return null;
+}
+// The figures off a seat's own pane: only a composer screen — idle, unsent or working — shows a
+// status row at all, and only that row's line is read. A dialog, a question, a trust screen or an
+// unknown one gives no figures, and neither does a line the seat printed or typed.
+function quotaOf(cli, screen, pane) {
+    if (pane === undefined)
+        return [];
+    if (screen.kind !== 'idle' && screen.kind !== 'unsent' && screen.kind !== 'working')
+        return [];
+    return figuresOf(quotaFor(cli), statusRow(cli, pane));
+}
+// One pass of the watch. Pure: it reads what it is handed and changes only `memory`.
+export function pass({ team, state, live, machine, now, memory, approval, watch = team.watch, outcomes = [], budgets = team.budgets, }) {
+    const reports = [];
+    const current = new Set();
+    // Reported when it starts, and again only after it has cleared.
+    const once = (key, text, to = 'operator') => {
+        current.add(key);
+        return memory.active.has(key) ? null : { key, text, to };
+    };
+    const known = new Set();
+    const workers = [];
+    const observations = [];
+    // A stopped seat is kept in the file and not started; should its owner start one by hand, herdr
+    // shows it running, and the watch gives it a parked seat's treatment: attention (permission,
+    // trust, question, blocked) and unsent text are reported, idle is not — and it is never an agent
+    // the file doesn't hold. A stopped seat that is not running is the normal state, and draws nothing.
+    const seats = [
+        ...team.seats.map((seat) => ({
+            name: seat.name,
+            cli: seat.cli,
+            vendor: seat.vendor,
+            parked: seat.parked || seat.stopped,
+            stopped: seat.stopped,
+            seat,
+        })),
+        ...Object.entries(state.seats).filter(([, recorded]) => recorded.temporary).map(([name, recorded]) => {
+            // A temporary seat signs like the seat it is like: its CLI, and its account.
+            const like = team.seats.find((seat) => seat.name === recorded.temporary?.like);
+            return { name, cli: like?.cli ?? '', vendor: like?.vendor ?? '', parked: false, stopped: false, seat: undefined };
+        }),
+    ];
+    for (const { name, cli, vendor, parked, stopped, seat } of seats) {
+        const agent = live.agents.find((candidate) => candidate.name === name);
+        const lead = name === team.coordinator || name === team.operator;
+        if (!agent) {
+            delete memory.history[name];
+            observations.push({
+                name,
+                seat,
+                agent: undefined,
+                herdr: live.running,
+                screen: { kind: 'unknown' },
+                cli,
+                vendor,
+                quota: [],
+                running: false,
+                quiet: false,
+                working: false,
+                prompt: false,
+                lead,
+                parked,
+                stopped,
+                attention: null,
+                model: null,
+                history: { lastWorking: undefined, idleSince: undefined },
+            });
+            continue;
+        }
+        known.add(agent.pane);
+        const pane = live.screens[agent.pane];
+        const screen = readScreen(cli, pane);
+        const quiet = agent.status === 'idle' || agent.status === 'done';
+        // Working is herdr's word or the screen's: a seat mid-turn is never idle, whatever its
+        // status says.
+        const working = agent.status === 'working' || screen.kind === 'working';
+        const prompt = screen.kind === 'permission' || screen.kind === 'trust' || screen.kind === 'question';
+        if (!lead && !parked)
+            workers.push({ idle: quiet && !working && !prompt });
+        // The history the idle clock counts from. A seat seen working starts it again; a seat quiet
+        // with no work behind it was already idle when the watch started, and counts from then.
+        const history = (memory.history[name] ??= { lastWorking: undefined, idleSince: undefined });
+        if (working) {
+            history.lastWorking = now;
+            delete history.idleSince;
+        }
+        else if (quiet && !prompt && !lead && !parked && history.lastWorking === undefined) {
+            history.idleSince ??= now;
+        }
+        observations.push({
+            name,
+            seat,
+            agent,
+            herdr: live.running,
+            screen,
+            cli,
+            vendor,
+            quota: quotaOf(cli, screen, pane),
+            running: true,
+            quiet,
+            working,
+            prompt,
+            lead,
+            parked,
+            stopped,
+            attention: attentionOf(screen, agent.status, quiet),
+            model: seat ? seatModel(seat, live.screens[agent.pane]) : null,
+            history: { lastWorking: history.lastWorking, idleSince: history.idleSince },
+        });
+    }
+    // The figures this pass saw, folded into the readings the state keeps (§ 4.3). Only an account
+    // whose `sources` name `status_line` takes a screen reading: a check-only account never records
+    // one here, and neither does an account the budgets in force don't name (#50).
+    let readings = recall(state.budgets);
+    for (const seat of observations) {
+        if (!seat.running)
+            continue;
+        for (const figure of seat.quota) {
+            if (budgets.accounts[figure.account]?.sources.includes('status_line')) {
+                readings = observe(readings, figure, seat.name, now);
+            }
+        }
+    }
+    const teamObservation = {
+        team,
+        state,
+        live,
+        machine,
+        limits: team.machine,
+        seats: observations,
+        known,
+        workers,
+        approval,
+        readings,
+        outcomes,
+    };
+    const ctx = {
+        now,
+        watch,
+        budgets,
+        once,
+        memory: (kind, start) => {
+            if (!Object.hasOwn(memory.slots, kind))
+                memory.slots[kind] = start();
+            return memory.slots[kind];
+        },
+    };
+    // The four § 4.2 keeps out of `watch.checks` run whatever the file says: the validation refuses
+    // them, and this holds even for a file that reached memory another way.
+    //
+    // And nothing is turned off until the owner approves (RFC 0002 § 4.2): a file whose
+    // `watch.checks` differs from the approved one, a file never approved, and an approval that
+    // wasn't looked at keep every check running and report the difference instead. A difference in
+    // some other section leaves the checks turned off as approved — the owner owns both questions.
+    const approved = Array.isArray(approval) && !approval.includes(WATCH_CHECKS_CHANGED);
+    const off = approved ? new Set(team.watch.checks) : new Set();
+    const enabled = (name) => ALWAYS_ON.includes(name) || !off.has(name);
+    for (const seat of observations) {
+        for (const check of SEAT_CHECKS)
+            if (enabled(check.name))
+                reports.push(...check.run(seat, ctx));
+    }
+    for (const check of TEAM_CHECKS)
+        if (enabled(check.name))
+            reports.push(...check.run(teamObservation, ctx));
+    memory.active = current;
+    // The nudge: kept until the operator is free, never typed into anything but an empty idle prompt.
+    for (const report of reports)
+        if (report.to === 'operator')
+            memory.pending.push(report.text);
+    let nudge = null;
+    let fallback = null;
+    if (memory.pending.length) {
+        memory.pendingSince ??= now;
+        const operator = live.agents.find((agent) => agent.name === team.operator);
+        const cli = team.seats.find((seat) => seat.name === team.operator)?.cli ?? '';
+        const free = operator !== undefined && (operator.status === 'idle' || operator.status === 'done')
+            && readScreen(cli, live.screens[operator.pane]).kind === 'idle';
+        if (operator && free) {
+            nudge = { pane: operator.pane, text: NUDGE_TEXT, pending: memory.pending.slice() };
+        }
+        else if (now - memory.pendingSince >= watch.nudgeWait * 1000) {
+            fallback = `the operator could not be nudged for ${minutes(now - memory.pendingSince)} minutes; ${memory.pending.length} report(s) wait: ${memory.pending.join('; ')}`;
+        }
+        if (nudge || fallback) {
+            memory.pending = [];
+            memory.pendingSince = null;
+        }
+    }
+    return { reports, nudge, fallback, readings };
+}

package/dist/watch/screen-core.d.ts

@@ -0,0 +1,20 @@
+import type { Screen } from './screen.ts';
+import type { ScreenData } from './screen-data.ts';
+export type { Composer, FallbackRule, LinePattern, Placeholder, Rule, ScreenData, Stage } from './screen-data.ts';
+export type ReadClock = {
+    now(): number;
+    budgetMs: number;
+};
+/**
+ * The one line a quota figure may be read from: the composer's own status row, or null when the
+ * window shows none. A dialog, a transcript line, the input box — anything the seat printed or
+ * typed — is never the row. The caller still has to know the screen is a composer screen.
+ */
+export declare function statusRowOf(data: ScreenData, lines: string[]): string | null;
+/** `lines` is already the window: the last 20 lines, each trimmed at the end. */
+export declare function classifyLines(data: ScreenData, lines: string[], clock?: ReadClock): Screen;
+/**
+ * The composer alone, for a turn that is still running. The unknown stage is
+ * read first, as in the full classification, and the floor still applies.
+ */
+export declare function composeLines(data: ScreenData, lines: string[], clock?: ReadClock): Screen;

package/dist/watch/screen-core.js

@@ -0,0 +1,356 @@
+const BUDGET_MS = 100;
+// The rule a `below_last_rule` pattern has to sit under. It is the core's, not the profile's.
+const RULE_LINE = /^\s*[─━]{8,}\s*$/;
+// The safety floor's markers, matched without case: a dialog's wording is not always title-case
+// (`Press enter to confirm or esc to cancel`). RFC 0002 § 4.1 permits it.
+const FLOOR_PHRASES = ['do you want to', 'esc to cancel', 'enter confirm', 'enter continue', 'esc quit', 'esc skip', '↑/↓'];
+/**
+ * The index of the composer's status line in the window, or -1. A `status-last` composer pins it
+ * as the last non-blank line; a `status-then-one` composer allows one chrome line below it. The
+ * classification and the quota read both take their line from here, so the two cannot disagree
+ * about which line the composer's status line is.
+ */
+function statusIndex(composer, lines, allowOneTrailing, tick) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (tick())
+            return 'stop';
+        if (!composer.statusLine.test(lines[i] ?? ''))
+            continue;
+        const trailing = lines.slice(i + 1).filter((line) => line.trim());
+        if (allowOneTrailing) {
+            if (trailing.length > 0 && (trailing.length > 1 || composer.prompt.test(trailing[0] ?? '')))
+                return -1;
+        }
+        else if (trailing.length > 0)
+            return -1;
+        return i;
+    }
+    return -1;
+}
+/**
+ * The one line a quota figure may be read from: the composer's own status row, or null when the
+ * window shows none. A dialog, a transcript line, the input box — anything the seat printed or
+ * typed — is never the row. The caller still has to know the screen is a composer screen.
+ */
+export function statusRowOf(data, lines) {
+    const composer = data.composer;
+    if (composer.mode !== 'status-last' && composer.mode !== 'status-then-one')
+        return null;
+    const at = statusIndex(composer, lines, composer.mode === 'status-then-one', () => false);
+    return at === 'stop' || at < 0 ? null : (lines[at] ?? null);
+}
+/** `lines` is already the window: the last 20 lines, each trimmed at the end. */
+export function classifyLines(data, lines, clock) {
+    const now = clock?.now ?? Date.now;
+    const budget = clock?.budgetMs ?? BUDGET_MS;
+    const start = now();
+    const tick = () => now() - start > budget;
+    const order = [
+        ['unknown', data.unknown],
+        ['trust', data.trust],
+        ['permission', data.permission],
+        ['question', data.question],
+        ['working', data.working],
+    ];
+    for (const [kind, stage] of order) {
+        if (!stage)
+            continue;
+        for (const rule of stage.rules) {
+            const hit = ruleMatches(data, lines, rule, tick);
+            if (hit === 'stop')
+                return { kind: 'unknown' };
+            if (hit)
+                return { kind };
+        }
+    }
+    const composed = compose(data, lines, tick);
+    if (composed.kind === 'stop' || composed.kind === 'unknown')
+        return { kind: 'unknown' };
+    if (composed.kind !== 'idle' && composed.kind !== 'unsent')
+        return { kind: composed.kind };
+    const marked = floorHits(lines, composed.from, composed.input, data.chrome, tick);
+    if (marked === 'stop' || marked)
+        return { kind: 'unknown' };
+    return { kind: composed.kind };
+}
+/**
+ * The composer alone, for a turn that is still running. The unknown stage is
+ * read first, as in the full classification, and the floor still applies.
+ */
+export function composeLines(data, lines, clock) {
+    const now = clock?.now ?? Date.now;
+    const budget = clock?.budgetMs ?? BUDGET_MS;
+    const start = now();
+    const tick = () => now() - start > budget;
+    if (data.unknown) {
+        for (const rule of data.unknown.rules) {
+            const hit = ruleMatches(data, lines, rule, tick);
+            if (hit === 'stop')
+                return { kind: 'unknown' };
+            if (hit)
+                return { kind: 'unknown' };
+        }
+    }
+    const composed = compose(data, lines, tick);
+    if (composed.kind === 'stop' || composed.kind === 'unknown')
+        return { kind: 'unknown' };
+    if (composed.kind !== 'idle' && composed.kind !== 'unsent')
+        return { kind: composed.kind };
+    const marked = floorHits(lines, composed.from, composed.input, data.chrome, tick);
+    if (marked === 'stop' || marked)
+        return { kind: 'unknown' };
+    return { kind: composed.kind };
+}
+function ruleMatches(data, lines, rule, tick) {
+    if (rule.any) {
+        const hit = anyLine(lines, rule.any, tick);
+        if (hit === 'stop')
+            return 'stop';
+        if (!hit)
+            return false;
+    }
+    if (rule.all) {
+        for (const pattern of rule.all) {
+            const hit = lineSomewhere(lines, pattern, tick);
+            if (hit === 'stop')
+                return 'stop';
+            if (!hit)
+                return false;
+        }
+    }
+    if (rule.footer !== undefined) {
+        if (footerLine(data, lines) !== rule.footer)
+            return false;
+    }
+    if (rule.belowLastRule) {
+        if (tick())
+            return 'stop';
+        // No rule line counts as below one: today's check is `index > lastIndex`, and
+        // lastIndex is -1 when the window has no rule. A later rule still hides a quoted dialog.
+        const ruleAt = findLast(lines, (line) => RULE_LINE.test(line));
+        const at = findLast(lines, (line) => rule.belowLastRule?.test(line) ?? false);
+        if (at < 0 || at <= ruleAt)
+            return false;
+    }
+    if (rule.noneAfter) {
+        let anchor = -1;
+        for (let i = 0; i < lines.length; i++) {
+            const hit = matches(lines[i] ?? '', rule.noneAfter.anchor, tick);
+            if (hit === 'stop')
+                return 'stop';
+            if (hit)
+                anchor = i;
+        }
+        if (anchor < 0)
+            return false;
+        for (let i = anchor + 1; i < lines.length; i++) {
+            const later = anyLine([lines[i] ?? ''], rule.noneAfter.patterns, tick);
+            if (later === 'stop')
+                return 'stop';
+            if (later)
+                return false;
+        }
+    }
+    return true;
+}
+function anyLine(lines, patterns, tick) {
+    for (const pattern of patterns) {
+        const hit = lineSomewhere(lines, pattern, tick);
+        if (hit === 'stop')
+            return 'stop';
+        if (hit)
+            return true;
+    }
+    return false;
+}
+function lineSomewhere(lines, pattern, tick) {
+    for (const line of lines) {
+        const hit = matches(line, pattern, tick);
+        if (hit === 'stop')
+            return 'stop';
+        if (hit)
+            return true;
+    }
+    return false;
+}
+/**
+ * The line a rule's footer must be: the last non-blank one. The composer's own chrome is the one
+ * thing allowed below it — a `status-last` mode pins the status line to the pane's last line, and
+ * a dialog drawn above it is still the dialog its footer belongs to. Any other line below the
+ * footer means the footer is not the dialog's, and the rule doesn't match.
+ */
+function footerLine(data, lines) {
+    const nonBlank = lines.filter((line) => line.trim());
+    const last = nonBlank[nonBlank.length - 1] ?? '';
+    const composer = data.composer;
+    if (composer.mode === 'status-last' && composer.statusLine.test(last)) {
+        return (nonBlank[nonBlank.length - 2] ?? '').trim();
+    }
+    return last.trim();
+}
+function matches(line, pattern, tick) {
+    if (tick())
+        return 'stop';
+    if (!pattern.match.test(line))
+        return false;
+    for (const except of pattern.except) {
+        if (tick())
+            return 'stop';
+        if (except.test(line))
+            return false;
+    }
+    return true;
+}
+function compose(data, lines, tick) {
+    const composer = data.composer;
+    if (composer.mode === 'box-to-rule')
+        return boxToRule(lines, composer, tick);
+    if (composer.mode === 'status-last')
+        return statusLast(lines, composer, tick, false);
+    if (composer.mode === 'status-then-one')
+        return statusThenOne(lines, composer, tick);
+    return twoRules(lines, composer, tick);
+}
+function boxToRule(lines, composer, tick) {
+    let input = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (tick())
+            return { kind: 'stop' };
+        if (composer.prompt.test(lines[i] ?? '')) {
+            input = i;
+            break;
+        }
+    }
+    if (input < 0)
+        return { kind: 'unknown' };
+    const from = boundaryBefore(lines, input, composer.rule);
+    for (let i = input + 1; i < lines.length; i++) {
+        if (tick())
+            return { kind: 'stop' };
+        if (composer.rule.test(lines[i] ?? ''))
+            break;
+        if ((lines[i] ?? '').trim())
+            return { kind: 'unsent', from, input };
+    }
+    const typed = (lines[input] ?? '').replace(composer.prompt, '').trim();
+    return { kind: placeholder(typed, composer.placeholders) ? 'idle' : 'unsent', from, input };
+}
+function statusLast(lines, composer, tick, allowOneTrailing) {
+    const status = statusIndex(composer, lines, allowOneTrailing, tick);
+    if (status === 'stop')
+        return { kind: 'stop' };
+    if (status < 0)
+        return { kind: 'unknown' };
+    let input = status - 1;
+    while (input >= 0 && !composer.prompt.test(lines[input] ?? ''))
+        input--;
+    if (input < 0)
+        return { kind: 'unknown' };
+    for (let i = input + 1; i < status; i++)
+        if ((lines[i] ?? '').trim())
+            return { kind: 'unsent', from: input, input };
+    return { kind: placeholder(stripTyped(lines[input] ?? '', composer), composer.placeholders) ? 'idle' : 'unsent', from: input, input };
+}
+function statusThenOne(lines, composer, tick) {
+    const found = statusLast(lines, composer, tick, true);
+    if (found.kind !== 'unknown')
+        return found;
+    // No status line: the fallback rules decide. Anything they don't name is unknown.
+    const hasStatus = lines.some((line) => composer.statusLine.test(line));
+    if (hasStatus)
+        return { kind: 'unknown' };
+    for (const rule of composer.fallback) {
+        let ok = true;
+        for (const pattern of rule.all) {
+            const hit = lineSomewhere(lines, pattern, tick);
+            if (hit === 'stop')
+                return { kind: 'stop' };
+            if (!hit) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok) {
+            // The floor's region starts at the prompt, the composer's top boundary.
+            // A phrase in the transcript above it is not the floor's to read.
+            const input = lines.findIndex((line) => composer.prompt.test(line));
+            return { kind: rule.kind, from: input < 0 ? 0 : input, input };
+        }
+    }
+    return { kind: 'unknown' };
+}
+function twoRules(lines, composer, tick) {
+    let bottom = -1;
+    let top = -1;
+    let input = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (tick())
+            return { kind: 'stop' };
+        const line = lines[i] ?? '';
+        if (composer.rule.test(line)) {
+            if (bottom === -1)
+                bottom = i;
+            else if (top === -1 && input !== -1) {
+                top = i;
+                break;
+            }
+        }
+        else if (bottom !== -1 && input === -1 && composer.prompt.test(line))
+            input = i;
+    }
+    if (top < 0 || bottom < 0 || input <= top || input >= bottom)
+        return { kind: 'unknown' };
+    let footer = false;
+    for (let i = bottom + 1; i < lines.length; i++) {
+        if (tick())
+            return { kind: 'stop' };
+        if (composer.footers.some((pattern) => pattern.test(lines[i] ?? '')))
+            footer = true;
+    }
+    if (!footer)
+        return { kind: 'unknown' };
+    if (lines.slice(input + 1, bottom).some((line) => line.trim()))
+        return { kind: 'unsent', from: top, input };
+    const typed = (lines[input] ?? '').replace(composer.prompt, '').trim();
+    return { kind: placeholder(typed, composer.placeholders) ? 'idle' : 'unsent', from: top, input };
+}
+function boundaryBefore(lines, input, rule) {
+    for (let i = input - 1; i >= 0; i--)
+        if (rule.test(lines[i] ?? ''))
+            return i;
+    return input;
+}
+function stripTyped(line, composer) {
+    const stripped = composer.stripSuffix ? line.replace(composer.prompt, '').replace(composer.stripSuffix, '') : line.replace(composer.prompt, '');
+    return stripped.trim();
+}
+function placeholder(typed, list) {
+    return list.some((entry) => ('equals' in entry ? typed === entry.equals : typed.startsWith(entry.prefix)));
+}
+function floorHits(lines, from, input, chrome, tick) {
+    for (let i = Math.max(0, from); i < lines.length; i++) {
+        if (tick())
+            return 'stop';
+        const line = lines[i] ?? '';
+        if (chrome.some((pattern) => pattern.test(line)))
+            continue;
+        if (i !== input && choiceLine(line) && lines.slice(i + 1).some((later) => twoLine(later)))
+            return true;
+        const lower = line.toLowerCase();
+        if (FLOOR_PHRASES.some((phrase) => lower.includes(phrase)))
+            return true;
+    }
+    return false;
+}
+function choiceLine(line) {
+    return /^\s*[❯›>]\s*1\.\s/.test(line);
+}
+function twoLine(line) {
+    return /^\s*[❯›>]?\s*2\.\s/.test(line);
+}
+function findLast(lines, test) {
+    for (let i = lines.length - 1; i >= 0; i--)
+        if (test(lines[i] ?? ''))
+            return i;
+    return -1;
+}