@vincemakes/kiso-tui 0.46.2 → 0.47.1

package/dist/ask-panel.d.ts

@@ -67,7 +67,7 @@ export declare function askCommitCustom(spec: AskSpec, state: AskRuntime, text:
  *  the widest label, never past the half-width, and 0 (meaning "no
  *  column, use the em dash") when what is left would not hold a
  *  readable description. */
-export declare function askDescriptionStop(q: AskQuestion, W: number): number;
+export declare function askDescriptionStop(q: AskQuestion, W: number, markCol?: boolean): number;
 /** The ask block's rows — the question as the rule line, the header (or
  *  the counter) as the title, the options as the body, and the
  *  type-your-own line last. R2: the shape is the RULE's — rule,
@@ -110,8 +110,8 @@ export declare function askAffordanceFit(state: AskRuntime, q: AskQuestion | und
 export declare function askStatus(view: PanelView, state: AskRuntime): string;
 /** The input row's lead: the digit lead while picking, the typing lead
  *  in the custom phase (the rule-input phase's shape, reused). */
-export declare function askLeadPlain(state: AskRuntime): string;
-export declare function panelBlockRows(view: PanelView, phase: PanelPhase, cursor: number, W: number, maxRows: number, ask?: AskRuntime, pick?: PickRuntime, note?: string, safer?: SaferRuntime): string[];
+export declare function askLeadPlain(_state: AskRuntime): string;
+export declare function panelBlockRows(view: PanelView, phase: PanelPhase, cursor: number, W: number, maxRows: number, ask?: AskRuntime, pick?: PickRuntime, note?: string, safer?: SaferRuntime, height?: number): string[];
 export declare function panelLead(view: PanelView, phase: PanelPhase, cursor: number, ask?: AskRuntime, pick?: PickRuntime): string;
 export declare function panelLeadPlain(view: PanelView, phase: PanelPhase, cursor: number, ask?: AskRuntime, pick?: PickRuntime): string;
 export declare function panelStatus(view: PanelView, phase: PanelPhase, cursor: number, ask?: AskRuntime, pick?: PickRuntime): string;
@@ -119,7 +119,7 @@ export declare function panelAffordance(view: PanelView, phase: PanelPhase, curs
 /** The whole panel state in one call — the compositor's four reads share
  *  one source, so an ask can never render half as an approval (TUI2-R2
  *  ④: nor a pick as either). */
-export declare const panelRowsOf: (s: PanelState, W: number, maxRows: number) => string[];
+export declare const panelRowsOf: (s: PanelState, W: number, maxRows: number, height?: number) => string[];
 /**
  * TUI2-R3v2 ② — the rows AND where the clickable ones are, from ONE
  * call.
@@ -136,7 +136,7 @@ export declare const panelRowsOf: (s: PanelState, W: number, maxRows: number) =>
  * not). A null here means every click is inert, which is the safe way
  * to not-implement something.
  */
-export declare const panelFrameOf: (s: PanelState, W: number, maxRows: number) => {
+export declare const panelFrameOf: (s: PanelState, W: number, maxRows: number, height?: number) => {
     rows: string[];
     options: {
         offset: number;
@@ -145,6 +145,11 @@ export declare const panelFrameOf: (s: PanelState, W: number, maxRows: number) =
     } | null;
 };
 export declare const panelLeadOf: (s: PanelState) => string;
+/** Graphite P3/P4: what an EMPTY input row says while a panel is up and the
+ *  composer is where the person types — a pick's filter, the note an
+ *  approval's amend sends, a typed answer to a question. Null: the row stays
+ *  empty, as §7.8 has it everywhere else. */
+export declare const panelHintOf: (s: PanelState) => string | null;
 export declare const panelStatusOf: (s: PanelState) => string;
 export declare const panelAffordanceOf: (s: PanelState) => string;
 /** The ask's PanelView. The dock-less fallback question is HONEST: a

package/dist/ask-panel.js

@@ -27,8 +27,9 @@
  * durability would need a new durable mechanism), no "chat about this"
  * hand-off, no timeout and no countdown.
  */
-import { panelBlockLayout, panelAffordance as basePanelAffordance, panelBlockRows as basePanelBlockRows, panelLead as basePanelLead, panelLeadPlain as basePanelLeadPlain, panelStatus as basePanelStatus, pickAffordance, pickBlockRows, pickLead, pickLeadPlain, pickStatus, } from "./approval-panel.js";
-import { cutLine, selectionBar, visibleWidth, widthCut } from "@vincemakes/kiso-tui-cells/components";
+import { panelBlockLayout, panelAffordance as basePanelAffordance, panelBlockRows as basePanelBlockRows, panelLead as basePanelLead, panelLeadPlain as basePanelLeadPlain, panelStatus as basePanelStatus, pickAffordance, pickBlockRows, pickLead, pickList, pickLeadPlain, pickStatus, foldAtSpaces, } from "./approval-panel.js";
+import { boxBottom, cutLine, selectionBar, visibleWidth, widthCut } from "@vincemakes/kiso-tui-cells/components";
+import { bandHeader } from "@vincemakes/kiso-tui-cells/strings";
 import { escapeTerminal, palette } from "./lines.js";
 /** The schema's own bounds — the registry refuses anything outside them
  *  (extensions/ask validates; these are the numbers it validates to). */
@@ -223,17 +224,26 @@ export function askCommitCustom(spec, state, text) {
  * A narrow block has no room for two columns; `stop` arrives as 0 and
  * the em-dash form is what it degrades to.
  */
-function optionRow(o, n, picked, cursor, multi, W, stop = 0) {
+function optionRow(o, n, picked, cursor, multi, W, stop = 0, markCol = multi, opened = false) {
     const p = palette();
-    const mark = multi ? (picked ? "◉" : "◯") : picked ? "◉" : " ";
+    // Graphite P4 follow-up: a single-select spends no mark column until one
+    // of its options is picked (walking back to an answered question shows
+    // its ◉) — the approved `1 vite`, where `1   vite` was drawn
+    const mark = multi ? (picked ? "◉" : "◯") : !markCol ? "" : picked ? "◉" : " ";
     const lead = askOptionLead(o, n, mark, cursor);
     const head = `${cursor ? p.bold : ""}${lead}${p.reset}`;
     const room = Math.max(1, W - 2);
     let body;
-    if (o.description === undefined)
+    // an OPENED option says its description on the rows under it, whole —
+    // its own row carries the label alone, so nothing is said twice
+    if (o.description === undefined || opened)
         body = "";
     else if (stop > 0) {
-        const desc = widthCut(escapeTerminal(o.description), Math.max(0, room - stop));
+        // cut by cells WITH an ellipsis — a bare cut reads as the whole
+        // sentence (the P2/P3 class, here in the model's descriptions)
+        const left = Math.max(0, room - stop);
+        const said = escapeTerminal(o.description);
+        const desc = visibleWidth(said) <= left ? said : left <= 1 ? "" : `${widthCut(said, left - 1)}…`;
         body = `${" ".repeat(Math.max(1, stop - visibleWidth(lead)))}${p.dim}${desc}${p.reset}`;
     }
     else
@@ -246,12 +256,35 @@ function optionRow(o, n, picked, cursor, multi, W, stop = 0) {
     // ruling, applied in the second place it was always about.
     return cursor ? selectionBar(text, visibleWidth(text), W) : ` ${text}`; // R2: the frame is a rule, so a row is just indented
 }
+/** Whether an option's description fits its row as drawn — in the column
+ *  when there is one, after an em dash when there is not. */
+function descriptionFits(o, n, mark, stop, W) {
+    const room = Math.max(1, W - 2);
+    const said = escapeTerminal(o.description ?? "");
+    if (stop > 0)
+        return visibleWidth(said) <= Math.max(0, room - stop);
+    return visibleWidth(askOptionLead(o, n, mark, false)) + 3 + visibleWidth(said) <= room;
+}
+/** The OPENED rows of the selected option: its description, whole, folded
+ *  at its spaces under the label's first cell, on the selection's wash. At
+ *  most three rows, the third cut with an ellipsis when it must be. */
+const OPENED_MAX = 3;
+function openedDescription(description, labelCol, W) {
+    const p = palette();
+    const width = Math.max(8, W - labelCol - 1);
+    let rows = foldAtSpaces(escapeTerminal(description), width);
+    if (rows.length > OPENED_MAX) {
+        const last = rows.slice(OPENED_MAX - 1).join(" ");
+        rows = [...rows.slice(0, OPENED_MAX - 1), visibleWidth(last) <= width ? last : `${widthCut(last, width - 1)}\u2026`];
+    }
+    return rows.map((r) => selectionBar(`${" ".repeat(Math.max(0, labelCol - 1))}${p.dim}${r}${p.reset}`, labelCol - 1 + visibleWidth(r), W));
+}
 /** The row's left span, PLAIN — the one place its shape is written, so
  *  the column arithmetic below and the row above cannot disagree about
  *  how wide it is. The arrow's cell is spent on every row so the digit
  *  column does not move as the cursor walks. */
 function askOptionLead(o, n, mark, cursor) {
-    return `${cursor ? "→" : " "} ${n} ${mark} ${escapeTerminal(o.label)}`;
+    return `${cursor ? "→" : " "} ${n} ${mark === "" ? "" : `${mark} `}${escapeTerminal(o.label)}`;
 }
 /** Below this many cells a right column is not a column, it is a
  *  three-word stub — the em-dash form carries more of the sentence. */
@@ -260,11 +293,11 @@ const ASK_DESC_MIN = 18;
  *  the widest label, never past the half-width, and 0 (meaning "no
  *  column, use the em dash") when what is left would not hold a
  *  readable description. */
-export function askDescriptionStop(q, W) {
+export function askDescriptionStop(q, W, markCol = q.multiSelect === true) {
     const multi = q.multiSelect === true;
     if (!q.options.some((o) => o.description !== undefined))
         return 0;
-    const widest = Math.max(...q.options.map((o, i) => visibleWidth(askOptionLead(o, i + 1, multi ? "◯" : " ", false))));
+    const widest = Math.max(...q.options.map((o, i) => visibleWidth(askOptionLead(o, i + 1, multi ? "◯" : markCol ? " " : "", false))));
     const room = Math.max(1, W - 2);
     const stop = widest + 2;
     if (stop > Math.floor(room / 2) || room - stop < ASK_DESC_MIN)
@@ -280,25 +313,34 @@ export function askBlockRows(view, state, W, maxRows) {
     const spec = view.ask;
     const q = spec.questions[state.qIndex];
     const multi = q.multiSelect === true;
-    const counter = spec.questions.length > 1 ? `${p.dim} ‹ ${state.qIndex + 1}/${spec.questions.length} ›${p.reset}` : "";
     const rows = [];
-    // R2: the same dashed rule the composer and the approval panel use.
-    rows.push(`${p.dim}${"\u2500".repeat(Math.max(0, W))}${p.reset}`);
-    rows.push(`  ${cutLine(`${p.bold}${escapeTerminal(q.question)}${p.reset}${counter}`, Math.max(1, W - 2))}`);
-    const header = q.header === undefined ? "the question" : escapeTerminal(q.header.slice(0, ASK_HEADER_CAP));
-    // R2: the divider row is gone (the opening rule says a block starts
-    // here), but the multi-select gesture it carried is INFORMATION and
-    // rides the header instead — dropping it would have been a regression
-    // wearing a restyle's clothes.
-    // R6/D2: the header names the MODE; the keys live on the keys row,
-    // once. It used to name `space toggles` there and nowhere say what
-    // finishes the set.
-    const gesture = multi ? `${p.dim} · pick any${p.reset}` : "";
-    rows.push(`  ${cutLine(`${p.dim}${header}${p.reset}${gesture}`, Math.max(1, W - 2))}`);
-    rows.push("");
+    // Graphite P4 (owner, 2026-10-04): the band's name carries the facts — the
+    // question's header, its place in the set, `pick any` — and the question
+    // is the first row, bold. DECLARED REVERSAL of the `‹ 1/2 ›` after the
+    // question, of the header's row of its own and of the blank row (R2,
+    // R6/D2): three rows before the options became one.
+    const facts = [
+        ...(q.header === undefined ? [] : [escapeTerminal(q.header.slice(0, ASK_HEADER_CAP))]),
+        ...(spec.questions.length > 1 ? [`${state.qIndex + 1} of ${spec.questions.length}`] : []),
+        ...(multi ? ["pick any"] : []),
+    ];
+    rows.push(bandHeader(["question", ...facts].join(" \u00b7 "), W));
+    rows.push(`  ${cutLine(`${p.bold}${escapeTerminal(q.question)}${p.reset}`, Math.max(1, W - 2))}`);
     const picks = state.picks[state.qIndex] ?? [];
-    const stop = askDescriptionStop(q, W);
-    const body = q.options.map((o, i) => optionRow(o, i + 1, picks.includes(i), state.cursor === i, multi, W, stop));
+    const markCol = multi || picks.length > 0;
+    const stop = askDescriptionStop(q, W, markCol);
+    // Graphite P4 (owner, 2026-10-05): the selected option OPENS when its
+    // description does not fit its row — its row keeps the label and the
+    // rows under it, on the same wash, say the description whole (the
+    // /resume and /model shape). The others keep their one row, cut.
+    const body = [];
+    q.options.forEach((o, i) => {
+        const on = state.cursor === i;
+        const opens = on && state.phase !== "custom" && o.description !== undefined && !descriptionFits(o, i + 1, multi ? "◯" : markCol ? " " : "", stop, W);
+        body.push(optionRow(o, i + 1, picks.includes(i), on, multi, W, stop, markCol, opens));
+        if (opens)
+            body.push(...openedDescription(o.description, visibleWidth(askOptionLead(o, i + 1, multi ? "◯" : markCol ? " " : "", false)) - visibleWidth(escapeTerminal(o.label)) + 1, W));
+    });
     // REL-0152-D3: the row is part of the list, so it carries the same
     // cursor affordance the options do. Dim-always made a reachable row
     // look like a footnote.
@@ -319,13 +361,13 @@ export function askBlockRows(view, state, W, maxRows) {
         ? `${onCustom || typingHere ? p.bold : ""}${customLead}◉ ${escapeTerminal(typed)}${p.reset}`
         : typingHere
             ? `${p.bold}${customLead}▸${p.reset} ${p.dim}type your answer — enter sends, esc backs out${p.reset}`
-            : `${onCustom ? p.bold : p.dim}${customLead}  type your own answer${p.reset}`, Math.max(1, W - 2));
+            : `${onCustom ? p.bold : p.dim}${customLead}${markCol ? "  " : ""}type your own answer${p.reset}`, Math.max(1, W - 2));
     body.push(onCustom ? selectionBar(customText, visibleWidth(customText), W) : ` ${customText}`);
     // the bounded block: the options fold nothing and cut individually,
     // so the cap drops whole rows with the W21 notice row.
-    // R2: SIX rows of frame — the block opens with a rule as well as
-    // closing with one, and the divider became a blank.
-    const budget = Math.max(1, maxRows - 6);
+    // P4: THREE rows of frame — the band's name, the question and the key
+    // row (no header row, no blank, no closing rule)
+    const budget = Math.max(1, maxRows - 3);
     if (body.length > budget) {
         const kept = Math.max(0, budget - 1);
         rows.push(...body.slice(0, kept));
@@ -335,14 +377,12 @@ export function askBlockRows(view, state, W, maxRows) {
         rows.push(...body);
     }
     // R6/D2: FITTED, and the two-space indent is inside the budget —
-    // the uncut push here is what made a narrow ask throw.
-    rows.push(`  ${p.dim}${askAffordanceFit(state, q, Math.max(1, W - 2))}${p.reset}`);
-    // R2, shared with the approval panel: the block closes with the SAME
-    // dashed rule it opened with, and the same one the composer uses.
-    // TUI2-R1.5 ⑪ had already replaced a two-cell `\u2514 ` stub with a
-    // real rule for the reason that stub read as the cut-notice prefix it
-    // collides with; this keeps that finding and only changes which rule.
-    rows.push(`${p.dim}${"\u2500".repeat(Math.max(0, W))}${p.reset}`);
+    // the uncut push here is what made a narrow ask throw. Graphite P4: the
+    // counter rides the right margin (§8.2), and the composer's rail closes
+    // the band — DECLARED REVERSAL of the block's own bottom rule (R2).
+    const count = `${state.cursor + 1}/${customRow(q) + 1}`;
+    const keys = askAffordanceFit(state, q, Math.max(1, W - 1 - 2 - count.length - 2));
+    rows.push(`  ${p.dim}${keys}${" ".repeat(Math.max(2, W - 1 - 2 - visibleWidth(keys) - count.length))}${count}${p.reset}`);
     return rows;
 }
 /**
@@ -368,8 +408,8 @@ export function askAffordance(state, q) {
     const multi = q?.multiSelect === true;
     const back = state.qIndex > 0 ? ["← back"] : [];
     return (multi
-        ? ["↑↓ move", `space or 1-${n} marks`, "⏎ sends the set", "t types", ...back, "esc declines"]
-        : ["↑↓ move", "⏎ confirms", `1-${n} instant`, "t types", ...back, "esc declines"]).join(" · ");
+        ? ["↑↓ move", `space or 1–${n} marks`, "⏎ sends the set", "t types", ...back, "esc declines"]
+        : ["↑↓ move", "⏎ confirms", `1–${n} instant`, "t types", ...back, "esc declines"]).join(" · ");
 }
 /**
  * The affordance at a width, by the DC-2 clause ladder.
@@ -392,13 +432,13 @@ export function askAffordanceFit(state, q, W) {
     const n = q?.options.length ?? 4;
     const multi = q?.multiSelect === true;
     const back = state.qIndex > 0 ? ["← back"] : [];
-    const act = multi ? `space or 1-${n} marks` : `1-${n} instant`;
+    const act = multi ? `space or 1–${n} marks` : `1–${n} instant`;
     const go = multi ? "⏎ sends the set" : "⏎ confirms";
     const tiers = [
         ["↑↓ move", act, go, "t types", ...back, "esc declines"],
         ["↑↓ move", act, go, ...back, "esc declines"],
         [act, go, ...back, "esc declines"],
-        [multi ? "space marks" : `1-${n} picks`, multi ? "⏎ sends" : "⏎ confirms", "esc declines"],
+        [multi ? "space marks" : `1–${n} picks`, multi ? "⏎ sends" : "⏎ confirms", "esc declines"],
         [multi ? "⏎ sends" : "⏎ confirms", "esc declines"],
     ];
     for (const tier of tiers) {
@@ -422,16 +462,18 @@ export function askStatus(view, state) {
 }
 /** The input row's lead: the digit lead while picking, the typing lead
  *  in the custom phase (the rule-input phase's shape, reused). */
-export function askLeadPlain(state) {
-    // REL-0152-D3: "1-4> " was hard-coded and wrong twice over — it named
-    // a range even when there were two options, and it excluded the
-    // type-your-own row the list shows.
-    return state.phase === "custom" ? "your answer: " : "pick> ";
+export function askLeadPlain(_state) {
+    // REL-0152-D3: "1-4> " was hard-coded and wrong twice over. Graphite P4
+    // (owner, 2026-10-04): a panel leaves the input row to the composer —
+    // `pick>` and `your answer:` retired; an empty answer row carries a dim
+    // hint instead (`panelHintOf`).
+    return "";
 }
 // ── the dispatchers: the panel slot, with the ask branch folded in ────
-export function panelBlockRows(view, phase, cursor, W, maxRows, ask, pick, note, safer) {
+export function panelBlockRows(view, phase, cursor, W, maxRows, ask, pick, note, safer, height = 24) {
+    // Graphite P3: a pick's window is §8.2's, so it reads the terminal's height
     if (view.pick !== undefined && pick !== undefined)
-        return pickBlockRows(view, pick, W, maxRows);
+        return pickBlockRows(view, pick, W, maxRows, height);
     if (view.ask !== undefined && ask !== undefined)
         return askBlockRows(view, ask, W, maxRows);
     return basePanelBlockRows(view, phase, cursor, W, maxRows, note, safer);
@@ -459,8 +501,10 @@ export function panelStatus(view, phase, cursor, ask, pick) {
     return basePanelStatus(view, phase, cursor);
 }
 export function panelAffordance(view, phase, cursor, ask, pick, safer) {
-    if (view.pick !== undefined && pick !== undefined)
-        return pickAffordance(pick, view.pick.options[pick.cursor]?.levels !== undefined);
+    if (view.pick !== undefined && pick !== undefined) {
+        const here = view.pick.options[pickList(view.pick, pick).cursor];
+        return pickAffordance(pick, here?.levels !== undefined ? (here.axisLabel ?? true) : false);
+    }
     if (view.ask !== undefined && ask !== undefined)
         return askAffordance(ask, view.ask.questions[ask.qIndex]);
     return basePanelAffordance(view, phase, cursor, safer);
@@ -468,7 +512,7 @@ export function panelAffordance(view, phase, cursor, ask, pick, safer) {
 /** The whole panel state in one call — the compositor's four reads share
  *  one source, so an ask can never render half as an approval (TUI2-R2
  *  ④: nor a pick as either). */
-export const panelRowsOf = (s, W, maxRows) => panelBlockRows(s.view, s.phase, s.cursor, W, maxRows, s.ask, s.pick, s.note, s.safer);
+export const panelRowsOf = (s, W, maxRows, height = 24) => panelBlockRows(s.view, s.phase, s.cursor, W, maxRows, s.ask, s.pick, s.note, s.safer, height);
 /**
  * TUI2-R3v2 ② — the rows AND where the clickable ones are, from ONE
  * call.
@@ -485,9 +529,9 @@ export const panelRowsOf = (s, W, maxRows) => panelBlockRows(s.view, s.phase, s.
  * not). A null here means every click is inert, which is the safe way
  * to not-implement something.
  */
-export const panelFrameOf = (s, W, maxRows) => {
+export const panelFrameOf = (s, W, maxRows, height = 24) => {
     if (s.view.pick !== undefined || s.view.ask !== undefined)
-        return { rows: panelRowsOf(s, W, maxRows), options: null };
+        return { rows: panelRowsOf(s, W, maxRows, height), options: null };
     const layout = panelBlockLayout(s.view, s.phase, s.cursor, W, maxRows, s.note, s.safer);
     return {
         rows: layout.rows,
@@ -495,6 +539,17 @@ export const panelFrameOf = (s, W, maxRows) => {
     };
 };
 export const panelLeadOf = (s) => panelLead(s.view, s.phase, s.cursor, s.ask, s.pick);
+/** Graphite P3/P4: what an EMPTY input row says while a panel is up and the
+ *  composer is where the person types — a pick's filter, the note an
+ *  approval's amend sends, a typed answer to a question. Null: the row stays
+ *  empty, as §7.8 has it everywhere else. */
+export const panelHintOf = (s) => {
+    if (s.view.pick !== undefined)
+        return s.view.pick.input === "filter" ? (s.view.pick.filterHint ?? null) : null;
+    if (s.view.ask !== undefined)
+        return s.ask?.phase === "custom" ? "your answer" : null;
+    return s.phase === "amend" ? "tell kiso what to do instead" : null;
+};
 export const panelStatusOf = (s) => panelStatus(s.view, s.phase, s.cursor, s.ask, s.pick);
 export const panelAffordanceOf = (s) => panelAffordance(s.view, s.phase, s.cursor, s.ask, s.pick, s.safer);
 // ── the view: what the human reads when the model asks ────────────────

package/dist/at-picker.d.ts

@@ -12,6 +12,8 @@
  * lexical order of the path (never localeCompare, whose result depends
  * on the machine's locale).
  */
+import { atEmbed, bandKeyRow, bandVisible, bandWindow, moreMark } from "./components.js";
+export { atEmbed, bandKeyRow, bandVisible, bandWindow, moreMark };
 import { bandHeader } from "@vincemakes/kiso-tui-cells/strings";
 /** The bound source's item — a repo-relative path and nothing else.
  *  Structural: the CLI passes whatever it likes as long as it has a
@@ -54,26 +56,6 @@ export declare const AT_SKIP: ReadonlySet<string>;
 /** KC3 §4 — the panel's visible height. A ceiling, not a promise: the
  *  compositor clamps further when the terminal is short. */
 export declare const AT_VISIBLE = 5;
-/**
- * The subsequence embedding, TIGHTENED — the two-pass walk every good
- * fuzzy finder uses, and the reason `@ra` emboldens the "ra" of
- * "src/range.js" rather than the r of "src" and the a of "range".
- *
- * Pass 1 walks forward and stops at the EARLIEST index that completes
- * the query — this both answers "does it match at all" and fixes the
- * right-hand edge. Pass 2 walks backward from that edge, taking the
- * LATEST position for each query character in turn, which slides every
- * matched character as far right as it can go without crossing the
- * next one. The result is the most clustered embedding that ends where
- * the earliest match ends.
- *
- * Case-insensitive: both sides are lowercased by the caller once per
- * query rather than once per character.
- *
- * Returns the ascending match indices, or null when the query is not a
- * subsequence of the path at all.
- */
-export declare function atEmbed(lowerPath: string, lowerQuery: string): number[] | null;
 /** The longest run of CONSECUTIVE indices in an ascending list. An
  *  empty query has no run — every path ties on it, and the rank falls
  *  through to path length. */
@@ -103,61 +85,49 @@ export declare function atFilter(items: readonly AtItem[], query: string): {
     matches: AtMatch[];
     capped: boolean;
 };
+/** The path split into the two columns the panel draws: the file's own
+ *  name, and the directory that qualifies it. A path with no slash is
+ *  all name and no directory. */
+/** The cells a file's NAME takes in its row — the measure the band's name
+ *  column is laid over (escaped as the row draws it, so the column a
+ *  wide or control-character name asks for is the one it gets). */
+export declare function atNameWidth(path: string): number;
 /**
- * KC3 §4 — the picker's WINDOW: which slice of the ranked list is on
- * screen. The window TRAILS the selection exactly as the composer's
- * own viewport trails the cursor (KC1 §5) — derived per read, never
- * stored, so it can never disagree with the selection it is meant to
- * follow.
- */
-export declare function atWindow(total: number, selected: number, visible?: number): {
-    first: number;
-    count: number;
-};
-/**
- * KC3 §4 — ONE row of the panel.
+ * KC3 §4, Graphite P2 (owner, 2026-10-03) — ONE row of the panel: the
+ * file's NAME, padded to the name column, then its FOLDER as a dim column,
+ * so the folders line up. The letters the query matched are gold in both.
  *
- * Two columns: the file's NAME on the left with its matched characters
- * bold, and the DIRECTORY dim on the right, pushed to the far edge.
- * The name is what the user is aiming at; the directory is what tells
- * two same-named files apart, which is why it is present but quiet.
+ * DECLARED REVERSAL of TUI2-R1.5 ⑧ (VD-9) in two parts: the folder no
+ * longer trails each name after an em dash — it is a column one gap after
+ * the longest name in the list (never the far edge, which was VD-9's
+ * complaint), so twenty rows read as a table; and a match inside the
+ * folder is drawn, gold, because the person typed it.
  *
- * The selected row carries `→` on the inverse band (SGR 7, closed with
- * 27 — never SGR 0, so it composes inside the row's own spans).
- *
- * The `hit` indices are over the FULL path, so they are shifted by the
- * directory's length to land on the name. A hit that falls INSIDE the
- * directory is simply not drawn bold — the directory column is
- * uniformly dim by design (a bold fragment in a right-aligned dim
- * column reads as damage, not as information).
- *
- * The row never exceeds W: the name cuts first (it is the flexible
- * column), and the directory is dropped entirely before the name is
- * cut to nothing.
+ * The name is the flexible column when the row is short: the folder gives
+ * way first, then the name is cut with an ellipsis.
  */
-export declare function atRow(match: AtMatch, selected: boolean, W: number): string;
-/**
- * KC3 §4 — the counter row: `(n/total)`, where n is the 1-based
- * position of the SELECTION in the whole ranked list, not in the
- * visible window. The user needs to know where they are in the list,
- * which the five visible rows cannot tell them.
- *
- * When the source list was truncated the row SAYS SO. A file picker
- * that quietly lists 2,000 of 40,000 files and shows a confident
- * "(3/1998)" is lying by omission; this one admits the horizon.
- */
-export declare function atCounterRow(selected: number, total: number, capped: boolean, W: number): string;
+export declare function atRow(match: AtMatch, selected: boolean, W: number, nameCol?: number, mark?: string | null): string;
+/** The band's state as the editor hands it over. `query`, `total` and
+ *  `nameCol` (the widest file name in the whole list, so the folder
+ *  column never moves while the person types) are Graphite P2's; absent,
+ *  the band still draws. */
+export interface AtPanelState {
+    readonly matches: readonly AtMatch[];
+    readonly selected: number;
+    readonly capped: boolean;
+    readonly query?: string;
+    readonly total?: number;
+    readonly nameCol?: number;
+}
 /**
- * KC3 §4 — the whole band: at most AT_VISIBLE windowed rows, then the
+ * KC3 §4, Graphite P2 — the whole band: the named hairline with the count
+ * (`files · 8`, `2 of 8 match`, and `first 2000 only` when the walk was
+ * cut), the windowed rows with their more-marks, and the key row with the
  * counter. Returned as plain strings for the menu-rows channel, which
- * already accounts them in chromeRows — the picker needs no geometry
- * of its own, which is the entire reason it rides that channel.
+ * already accounts them in chromeRows — the picker needs no geometry of
+ * its own, which is the entire reason it rides that channel.
  */
-export declare function atPanelRows(state: {
-    matches: readonly AtMatch[];
-    selected: number;
-    capped: boolean;
-}, W: number): string[];
+export declare function atPanelRows(state: AtPanelState, W: number, height?: number): string[];
 /**
  * TUI2-R1.5 ⑦(b) — the one row that turns a band into a surface. Shared
  * by the @ picker, the / menu and the session picker so the three read