team 0.1.2 → 0.2.0

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

@@ -1,3 +1,4 @@
+import type { ScreenProfile } from './screen-profile.ts';
 import type { Screen } from './screen.ts';
 export type LinePattern = {
     match: RegExp;
@@ -25,6 +26,13 @@ export type Placeholder = {
 } | {
     prefix: string;
 };
+/** How a composer continues a line onto its next row, from a capture that shows it: the
+ *  continuation starts at the text column (the box's own indent), and the break folds the space
+ *  away at a word boundary or falls mid-word (hard). */
+export type Wrap = {
+    continuation: 'text-column';
+    kind: 'word' | 'hard';
+};
 export type FallbackRule = {
     all: LinePattern[];
     kind: Screen['kind'];
@@ -34,8 +42,15 @@ type Box = {
     mode: 'box-to-rule';
     prompt: RegExp;
     rule: RegExp;
+    /**
+     * For a scrolled-out box, the non-blank lines under the closing rule must match
+     * every pattern, in order, and the counts must be equal.
+     */
+    footers: RegExp[];
     placeholders: Placeholder[];
     placeholderStyle?: PlaceholderStyle;
+    wrap?: Wrap;
+    frameRows: number;
 };
 type StatusLast = {
     mode: 'status-last';
@@ -43,6 +58,8 @@ type StatusLast = {
     prompt: RegExp;
     placeholders: Placeholder[];
     placeholderStyle?: PlaceholderStyle;
+    wrap?: Wrap;
+    frameRows: number;
 };
 type StatusThenOne = {
     mode: 'status-then-one';
@@ -52,14 +69,21 @@ type StatusThenOne = {
     placeholderStyle?: PlaceholderStyle;
     stripSuffix: RegExp | null;
     fallback: FallbackRule[];
+    wrap?: Wrap;
+    frameRows: number;
 };
 type TwoRules = {
     mode: 'two-rules-footer-below';
     prompt: RegExp;
     rule: RegExp;
+    /** Any line below the closing rule matches any pattern in the list. */
     footers: RegExp[];
     placeholders: Placeholder[];
+    /** A row that stands for hidden rows of a folded paste; capture 1 is the hidden count. */
+    fold: RegExp | null;
     placeholderStyle?: PlaceholderStyle;
+    wrap?: Wrap;
+    frameRows: number;
 };
 export type Composer = Box | StatusLast | StatusThenOne | TwoRules;
 export type ScreenData = {
@@ -70,5 +94,6 @@ export type ScreenData = {
     question?: Stage;
     working?: Stage;
     composer: Composer;
+    profile?: ScreenProfile;
 };
 export {};

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

@@ -1,2 +1,8 @@
-import type { ScreenData } from './screen-data.ts';
-export declare function loadScreen(text: string): ScreenData;
+import type { Rule, ScreenData } from './screen-data.ts';
+import { type YamlNode } from '../yaml.ts';
+export declare function loadScreen(text: string, baseDir?: string, profileFile?: string): ScreenData;
+/**
+ * Rules an override adds to one dialog stage. The stage is a list of patterns:
+ * a map would be a case flag or a renamed stage, and neither is an added pattern.
+ */
+export declare function addedRules(node: YamlNode): Rule[];

package/dist/watch/screen-file.js

@@ -1,34 +1,240 @@
 // A profile file, in team's YAML subset, checked as it is loaded. The JSON Schema
 // next to the profiles describes the same shape; this is what actually refuses a file,
 // because the package does not carry a schema validator.
+import { existsSync, realpathSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { isAbsolute, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { DialectError, compilePattern } from "./dialect.js";
 import { YamlError, parseYaml } from "../yaml.js";
+const require = createRequire(import.meta.url);
 const STAGES = ['unknown', 'trust', 'permission', 'question', 'working'];
 const KINDS = ['idle', 'working', 'unsent', 'permission', 'trust', 'question', 'unknown'];
-const CHOICE_SAMPLES = ['❯ 1. Yes', '› 1. Yes', '> 1. Yes', '❯ 1.', '› 1.', '> 1.'];
-export function loadScreen(text) {
+// The lines a dialog draws for its choices, built from their parts: the mark on the choice
+// the cursor is on (claude-code ❯, codex ›, antigravity >) or the indent of the others, the
+// number, and the labels the profiles' rules and fixtures show, run-on forms included — the
+// trust dialog's "Yes, I trust this folder" and "No, exit", the permission dialog's "No, and
+// tell Claude what to do differently" (escape hint and all), codex's "Yes, proceed (y)" and
+// its own long No. The safety floor reads the first two numbered lines (screen-core's
+// choiceLine and twoLine), so chrome must match none of them.
+const CHOICE_MARKS = ['❯ ', '› ', '> ', '  '];
+const CHOICE_TAILS = [
+    '',
+    ' Yes',
+    ' No',
+    ' Yes, I trust this folder',
+    ' No, exit',
+    ' No, and tell Claude what to do differently',
+    ' No, and tell Claude what to do differently (esc)',
+    ' Yes, proceed (y)',
+    ' No, and tell Codex what to do differently (esc)',
+];
+const CHOICE_SAMPLES = CHOICE_MARKS.flatMap((mark) => ['1', '2'].flatMap((number) => CHOICE_TAILS.map((tail) => `${mark}${number}.${tail}`)));
+const DEFAULT_COMPOSER = {
+    mode: 'box-to-rule',
+    prompt: /(?!)/,
+    rule: /(?!)/,
+    footers: [],
+    placeholders: [],
+    frameRows: 0,
+};
+export function loadScreen(text, baseDir, profileFile) {
     const root = parseYaml(text);
     const entries = mapping(root, 'a profile');
     // Launch keys are read by profile.ts. A screen-only snippet, as in the tests, omits them.
-    only(entries, ['format', 'cli', 'screen', 'quota', 'binary', 'process_names', 'tested', 'unattended', 'rules', 'login', 'exit', 'timeouts', 'models', 'status_model']);
+    only(entries, ['format', 'cli', 'screen', 'screen_module', 'quota', 'binary', 'process_names', 'tested', 'unattended', 'rules', 'login', 'exit', 'timeouts', 'models', 'status_model']);
     const format = required(entries, 'format', root.line);
     if (format.value.kind !== 'scalar' || format.value.value !== 1)
         fail(format.line, '"format" must be 1');
     const cli = required(entries, 'cli', root.line);
     if (!stringOf(cli.value))
         fail(cli.line, '"cli" must be a string');
+    const topScreenModule = optional(entries, 'screen_module');
     const screen = required(entries, 'screen', root.line);
-    return screenOf(screen.value);
+    return deepFreeze(screenOf(screen.value, topScreenModule, baseDir, profileFile));
 }
-function screenOf(node) {
+function deepFreeze(obj) {
+    if (obj === null || typeof obj !== 'object' || obj instanceof RegExp)
+        return obj;
+    if (Object.isFrozen(obj))
+        return obj;
+    Object.freeze(obj);
+    for (const key of Object.getOwnPropertyNames(obj)) {
+        const val = obj[key];
+        if (val !== null && typeof val === 'object' && !(val instanceof RegExp)) {
+            deepFreeze(val);
+        }
+    }
+    return obj;
+}
+function loadScreenModule(specifier, baseDir, line, profileFile) {
+    const label = profileFile ? `profile "${profileFile}"` : 'profile';
+    // 1. Refuse empty string
+    if (!specifier || specifier.trim() === '') {
+        fail(line, `${label}: "screen_module" cannot be an empty string`);
+    }
+    // 2. Refuse current directory "."
+    if (specifier === '.' || specifier === './' || specifier === '.\\') {
+        fail(line, `${label}: "screen_module" cannot be current directory "."`);
+    }
+    // 3. Refuse absolute path
+    if (isAbsolute(specifier) || specifier.startsWith('/') || specifier.startsWith('\\')) {
+        fail(line, `${label}: "screen_module" cannot be an absolute path: "${specifier}"`);
+    }
+    // 4. Refuse home directory path
+    if (specifier.startsWith('~')) {
+        fail(line, `${label}: "screen_module" cannot be a home directory path: "${specifier}"`);
+    }
+    // 5. Refuse URL or other scheme
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(specifier)) {
+        fail(line, `${label}: "screen_module" cannot be a URL or scheme: "${specifier}"`);
+    }
+    // 6. Refuse ".." segment
+    if (specifier.split(/[/\\]/).includes('..') || /%2[eE]%2[eE]/.test(specifier)) {
+        fail(line, `${label}: "screen_module" cannot contain ".." segments: "${specifier}"`);
+    }
+    const defaultDir = fileURLToPath(new URL('../profiles', import.meta.url));
+    const dir = baseDir ? resolve(baseDir) : defaultDir;
+    const resolvedDir = resolve(dir);
+    // 7. Refuse paths in the project outside profiles
+    const projectSegments = ['test', 'src', 'dist', 'scripts', 'examples', 'node_modules', 'worktrees', '.github'];
+    const stripped = specifier.replace(/^(?:\.[/\\])+/, '');
+    const firstSegment = stripped.split(/[/\\]/)[0] ?? '';
+    if (projectSegments.includes(firstSegment) ||
+        (existsSync(resolve(process.cwd(), specifier)) && !resolve(process.cwd(), specifier).startsWith(resolvedDir + sep))) {
+        fail(line, `${label}: "screen_module" cannot be a path in the project: "${specifier}"`);
+    }
+    // 8. Must resolve inside profiles directory
+    let target = resolve(resolvedDir, specifier);
+    if (!target.startsWith(resolvedDir + sep) && target !== resolvedDir) {
+        fail(line, `${label}: "screen_module" must resolve inside profiles directory: "${specifier}"`);
+    }
+    // Check if target exists and if it is a directory or symlink loop
+    let st;
+    try {
+        st = statSync(target);
+    }
+    catch (err) {
+        if (err && err.code === 'ELOOP') {
+            fail(line, `${label}: "screen_module" contains a symlink loop: "${specifier}"`);
+        }
+    }
+    if (st && st.isDirectory()) {
+        fail(line, `${label}: "screen_module" cannot be a directory: "${specifier}"`);
+    }
+    // 9. Refuse bare names or paths without a script extension (.ts, .js, .cjs, .mjs)
+    if (!/\.(ts|js|cjs|mjs)$/.test(specifier)) {
+        if (!specifier.includes('/') && !specifier.includes('\\') && !/\.[^/\\]+$/.test(specifier)) {
+            fail(line, `${label}: "screen_module" cannot be a bare name: "${specifier}"`);
+        }
+        fail(line, `${label}: "screen_module" must have a script extension (.ts, .js, .cjs, .mjs): "${specifier}"`);
+    }
+    let fileTarget = target;
+    if (!existsSync(fileTarget)) {
+        if (fileTarget.endsWith('.ts') && existsSync(fileTarget.slice(0, -3) + '.js')) {
+            fileTarget = fileTarget.slice(0, -3) + '.js';
+        }
+        else if (fileTarget.endsWith('.js') && existsSync(fileTarget.slice(0, -3) + '.ts')) {
+            fileTarget = fileTarget.slice(0, -3) + '.ts';
+        }
+    }
+    let fileStat;
+    try {
+        fileStat = statSync(fileTarget);
+    }
+    catch (err) {
+        if (err && err.code === 'ELOOP') {
+            fail(line, `${label}: "screen_module" contains a symlink loop: "${specifier}"`);
+        }
+        fail(line, `${label}: cannot load "screen_module": Cannot find module "${specifier}"`);
+    }
+    if (!fileStat.isFile()) {
+        if (fileStat.isDirectory()) {
+            fail(line, `${label}: "screen_module" cannot be a directory: "${specifier}"`);
+        }
+        fail(line, `${label}: cannot load "screen_module": Cannot find module "${specifier}"`);
+    }
+    // Symlink check: realpath must be inside profiles directory
+    let realTarget;
+    let realDir;
+    try {
+        realTarget = realpathSync(fileTarget);
+        realDir = realpathSync(resolvedDir);
+    }
+    catch (err) {
+        if (err && err.code === 'ELOOP') {
+            fail(line, `${label}: "screen_module" contains a symlink loop: "${specifier}"`);
+        }
+        fail(line, `${label}: cannot load "screen_module": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!realTarget.startsWith(realDir + sep) && realTarget !== realDir) {
+        fail(line, `${label}: "screen_module" symlink leads outside profiles directory: "${specifier}"`);
+    }
+    let mod;
+    try {
+        mod = require(realTarget);
+    }
+    catch (error) {
+        fail(line, `${label}: cannot load "screen_module": ${error instanceof Error ? error.message : String(error)}`);
+    }
+    try {
+        const defaultExport = (typeof mod === 'object' && mod !== null) || typeof mod === 'function'
+            ? mod.default
+            : undefined;
+        const candidate = defaultExport && (typeof defaultExport === 'object' || typeof defaultExport === 'function')
+            ? defaultExport
+            : mod;
+        const readExport = (key) => {
+            let val = candidate !== null && (typeof candidate === 'object' || typeof candidate === 'function')
+                ? candidate[key]
+                : undefined;
+            if (val === undefined && mod !== candidate && mod !== null && (typeof mod === 'object' || typeof mod === 'function')) {
+                val = mod[key];
+            }
+            return typeof val === 'function' ? val : undefined;
+        };
+        const snapshot = Object.freeze({
+            unknown: readExport('unknown'),
+            trust: readExport('trust'),
+            permission: readExport('permission'),
+            question: readExport('question'),
+            working: readExport('working'),
+            composer: readExport('composer'),
+        });
+        return snapshot;
+    }
+    catch (error) {
+        fail(line, `${label}: cannot load "screen_module": ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function screenOf(node, topScreenModule, baseDir, profileFile) {
     const entries = mapping(node, 'screen');
-    only(entries, ['chrome', 'composer', ...STAGES]);
+    only(entries, ['chrome', 'composer', 'screen_module', ...STAGES]);
     const chrome = optional(entries, 'chrome');
-    const composer = required(entries, 'composer', node.line);
+    const screenScreenModule = optional(entries, 'screen_module');
+    const moduleEntry = screenScreenModule ?? topScreenModule;
+    const composer = optional(entries, 'composer');
+    const label = profileFile ? `profile "${profileFile}"` : 'profile';
+    let profile;
+    if (moduleEntry) {
+        const specifier = stringOf(moduleEntry.value);
+        if (specifier === null)
+            fail(moduleEntry.line, '"screen_module" must be a string');
+        profile = loadScreenModule(specifier, baseDir, moduleEntry.line, profileFile);
+    }
+    // Rule (b): A composer comes from data or from the hatch, never both; the load refuses both.
+    if (composer && typeof profile?.composer === 'function') {
+        fail(moduleEntry.line, `${label}: profile has a data composer and screen_module exports a composer: a composer comes from data or from the hatch, never both`);
+    }
+    if (!composer && typeof profile?.composer !== 'function') {
+        fail(node.line, `${label}: missing "composer"`);
+    }
     const data = {
         chrome: chrome ? chromeOf(chrome.value) : [],
-        composer: composerOf(composer.value),
+        composer: composer ? composerOf(composer.value) : DEFAULT_COMPOSER,
     };
+    if (profile)
+        data.profile = profile;
     for (const name of STAGES) {
         const entry = optional(entries, name);
         if (entry)
@@ -36,6 +242,17 @@ function screenOf(node) {
     }
     return data;
 }
+/**
+ * Rules an override adds to one dialog stage. The stage is a list of patterns:
+ * a map would be a case flag or a renamed stage, and neither is an added pattern.
+ */
+export function addedRules(node) {
+    if (node.kind !== 'seq' || node.items.length === 0)
+        fail(node.line, 'an override adds a non-empty list of patterns');
+    // A shipped profile may set a pattern's own case. An override may not: the flag would
+    // loosen a match the shipped patterns made case-sensitively.
+    return node.items.map((item) => ruleOf(item, false, false));
+}
 function stageOf(node) {
     if (node.kind === 'seq')
         return { rules: node.items.map((item) => ruleOf(item, false)) };
@@ -48,7 +265,7 @@ function stageOf(node) {
         fail(rules.line, '"rules" must be a list');
     return { rules: rules.value.items.map((item) => ruleOf(item, ignoreCase)) };
 }
-function ruleOf(node, ignoreCase) {
+function ruleOf(node, ignoreCase, allowCase = true) {
     const entries = mapping(node, 'a rule');
     only(entries, ['any', 'all', 'footer', 'on_footer', 'below_last_rule', 'without_rule', 'none_after']);
     if (entries.length === 0)
@@ -62,9 +279,9 @@ function ruleOf(node, ignoreCase) {
     const withoutRule = optional(entries, 'without_rule');
     const noneAfter = optional(entries, 'none_after');
     if (any)
-        rule.any = patternsOf(any.value, 'any', ignoreCase);
+        rule.any = patternsOf(any.value, 'any', ignoreCase, allowCase);
     if (all)
-        rule.all = patternsOf(all.value, 'all', ignoreCase);
+        rule.all = patternsOf(all.value, 'all', ignoreCase, allowCase);
     if (footer)
         rule.footer = stringOf(footer.value) ?? fail(footer.line, '"footer" must be a string');
     if (onFooter)
@@ -74,25 +291,29 @@ function ruleOf(node, ignoreCase) {
     if (withoutRule)
         rule.withoutRule = boolOf(withoutRule.value, 'without_rule');
     if (noneAfter)
-        rule.noneAfter = noneAfterOf(noneAfter.value, ignoreCase);
+        rule.noneAfter = noneAfterOf(noneAfter.value, ignoreCase, allowCase);
     return rule;
 }
-function noneAfterOf(node, ignoreCase) {
+function noneAfterOf(node, ignoreCase, allowCase = true) {
     const entries = mapping(node, 'none_after');
     only(entries, ['anchor', 'patterns']);
     const anchor = required(entries, 'anchor', node.line);
     const patterns = required(entries, 'patterns', node.line);
     return {
-        anchor: linePattern(anchor.value, ignoreCase),
-        patterns: patternsOf(patterns.value, 'patterns', ignoreCase),
+        anchor: linePattern(anchor.value, ignoreCase, allowCase),
+        patterns: patternsOf(patterns.value, 'patterns', ignoreCase, allowCase),
     };
 }
-function patternsOf(node, key, ignoreCase) {
+function patternsOf(node, key, ignoreCase, allowCase = true) {
     if (node.kind !== 'seq' || node.items.length === 0)
         fail(node.line, `"${key}" must be a non-empty list`);
-    return node.items.map((item) => linePattern(item, ignoreCase));
+    return node.items.map((item) => linePattern(item, ignoreCase, allowCase));
 }
-function linePattern(node, ignoreCase) {
+// A pattern is a string, or a mapping with `match`, its optional `except` list and its
+// own `ignore_case`. The pattern's flag is read with the stage's: a screen whose own
+// case varies carries the flag beside the pattern, where a stage-wide flag would reach
+// every rule. The flag is the entry's, so `except` is read on the same lines `match` is.
+function linePattern(node, ignoreCase, allowCase = true) {
     if (node.kind === 'scalar') {
         const text = stringOf(node);
         if (text === null)
@@ -100,13 +321,17 @@ function linePattern(node, ignoreCase) {
         return { match: patternOf(text, ignoreCase, node.line), except: [] };
     }
     const entries = mapping(node, 'a pattern');
-    only(entries, ['match', 'except']);
+    only(entries, ['match', 'except', 'ignore_case']);
     const match = required(entries, 'match', node.line);
     const text = stringOf(match.value);
     if (text === null)
         fail(match.line, '"match" must be a string');
+    const flag = optional(entries, 'ignore_case');
+    if (flag && !allowCase)
+        fail(flag.line, 'unknown key "ignore_case"');
+    const own = flag ? boolOf(flag.value, 'ignore_case') : false;
     const except = optional(entries, 'except');
-    return { match: patternOf(text, ignoreCase, match.line), except: except ? exceptOf(except.value, ignoreCase) : [] };
+    return { match: patternOf(text, ignoreCase || own, match.line), except: except ? exceptOf(except.value, ignoreCase || own) : [] };
 }
 function exceptOf(node, ignoreCase) {
     if (node.kind !== 'seq' || node.items.length === 0)
@@ -126,16 +351,38 @@ function composerOf(node) {
     // a composer whose suggestions plain text already names needs none of it.
     const style = optional(entries, 'placeholder_style');
     const placeholderStyle = style ? placeholderStyleOf(style) : undefined;
+    // How the box continues a line onto its next row, declared only where a capture showed the
+    // wrap. A composer without one is read by tiling the typed text's own runs.
+    const wrapEntry = optional(entries, 'wrap');
+    const wrap = wrapEntry ? wrapOf(wrapEntry) : undefined;
+    // The empty rows a capture shows the pane drawing under the text, inside the box's frame —
+    // the drop before the status line, or the closing rule. Counted from the captures; a
+    // composer whose captures show none declares none, and the box read then keeps every
+    // trailing empty row and refuses one the typed text does not have. Don't guess.
+    const frameEntry = optional(entries, 'frame_rows');
+    const frameRows = frameEntry ? frameRowsOf(frameEntry) : 0;
     if (name === 'box-to-rule') {
-        only(entries, ['mode', 'prompt', 'rule', 'placeholders', 'placeholder_style']);
-        return { mode: name, prompt: regexField(entries, 'prompt', node.line), rule: regexField(entries, 'rule', node.line), placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value), placeholderStyle };
+        only(entries, ['mode', 'prompt', 'rule', 'footers', 'placeholders', 'placeholder_style', 'wrap', 'frame_rows']);
+        // For a scrolled-out box, the non-blank lines under the closing rule must match
+        // every pattern, in order, and the counts must be equal.
+        const footers = optional(entries, 'footers');
+        return {
+            mode: name,
+            prompt: regexField(entries, 'prompt', node.line),
+            rule: regexField(entries, 'rule', node.line),
+            footers: footers ? footersOf(footers, false) : [],
+            placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value),
+            placeholderStyle,
+            wrap,
+            frameRows,
+        };
     }
     if (name === 'status-last') {
-        only(entries, ['mode', 'status_line', 'prompt', 'placeholders', 'placeholder_style']);
-        return { mode: name, statusLine: regexField(entries, 'status_line', node.line), prompt: regexField(entries, 'prompt', node.line), placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value), placeholderStyle };
+        only(entries, ['mode', 'status_line', 'prompt', 'placeholders', 'placeholder_style', 'wrap', 'frame_rows']);
+        return { mode: name, statusLine: regexField(entries, 'status_line', node.line), prompt: regexField(entries, 'prompt', node.line), placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value), placeholderStyle, wrap, frameRows };
     }
     if (name === 'status-then-one') {
-        only(entries, ['mode', 'status_line', 'prompt', 'placeholders', 'placeholder_style', 'strip_suffix', 'fallback']);
+        only(entries, ['mode', 'status_line', 'prompt', 'placeholders', 'placeholder_style', 'strip_suffix', 'fallback', 'wrap', 'frame_rows']);
         const suffix = optional(entries, 'strip_suffix');
         const fallback = required(entries, 'fallback', node.line);
         return {
@@ -144,33 +391,64 @@ function composerOf(node) {
             prompt: regexField(entries, 'prompt', node.line),
             placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value),
             placeholderStyle,
-            stripSuffix: suffix ? patternOf(stringOf(suffix.value) ?? fail(suffix.line, '"strip_suffix" must be a string'), false, suffix.line) : null,
+            stripSuffix: suffix ? composerString(suffix.value, 'strip_suffix', suffix.line) : null,
             fallback: fallbackOf(fallback.value),
+            wrap,
+            frameRows,
         };
     }
     if (name === 'two-rules-footer-below') {
-        only(entries, ['mode', 'ignore_case', 'prompt', 'rule', 'footers', 'placeholders', 'placeholder_style']);
+        only(entries, ['mode', 'ignore_case', 'prompt', 'rule', 'footers', 'placeholders', 'fold', 'placeholder_style', 'wrap', 'frame_rows']);
         const flag = optional(entries, 'ignore_case');
         const ignoreCase = flag ? boolOf(flag.value, 'ignore_case') : false;
+        // Any line below the closing rule matches any pattern in the list.
         const footers = required(entries, 'footers', node.line);
-        if (footers.value.kind !== 'seq' || footers.value.items.length === 0)
-            fail(footers.line, '"footers" must be a non-empty list');
+        const fold = optional(entries, 'fold');
         return {
             mode: name,
             prompt: regexField(entries, 'prompt', node.line, ignoreCase),
             rule: regexField(entries, 'rule', node.line, ignoreCase),
-            footers: footers.value.items.map((item) => {
-                const text = stringOf(item);
-                if (text === null)
-                    fail(item.line, '"footers" entries must be strings');
-                return patternOf(text, ignoreCase, item.line);
-            }),
+            footers: footersOf(footers, ignoreCase),
             placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value),
+            fold: fold ? patternOf(stringOf(fold.value) ?? fail(fold.line, '"fold" must be a string'), ignoreCase, fold.line) : null,
             placeholderStyle,
+            wrap,
+            frameRows,
         };
     }
     fail(mode.line, `"mode" must be box-to-rule, status-last, status-then-one or two-rules-footer-below`);
 }
+// The composer's wrap rule: the continuation starts at the text column and the break is at a
+// word boundary or hard. Either alone does not join a wrapped box — where it starts and where
+// it breaks are both needed — so both keys are required and nothing else is read.
+function wrapOf(entry) {
+    const entries = mapping(entry.value, 'wrap');
+    only(entries, ['continuation', 'kind']);
+    const continuation = required(entries, 'continuation', entry.line);
+    const where = stringOf(continuation.value);
+    if (where !== 'text-column')
+        fail(continuation.line, '"continuation" must be text-column');
+    const kind = required(entries, 'kind', entry.line);
+    const shape = stringOf(kind.value);
+    if (shape !== 'word' && shape !== 'hard')
+        fail(kind.line, '"kind" must be word or hard');
+    return { continuation: where, kind: shape };
+}
+// The pane's own empty rows inside a box's frame, as a capture shows them: a whole number,
+// zero or more. Omitting the key is how a composer whose captures show no such row declares
+// zero — the box read then keeps every trailing empty row.
+function frameRowsOf(entry) {
+    const value = entry.value;
+    if (value.kind !== 'scalar' || typeof value.value !== 'number' || !Number.isInteger(value.value) || value.value < 0) {
+        fail(entry.line, '"frame_rows" must be a whole number of rows, zero or more');
+    }
+    return value.value;
+}
+function footersOf(entry, ignoreCase) {
+    if (entry.value.kind !== 'seq' || entry.value.items.length === 0)
+        fail(entry.line, '"footers" must be a non-empty list');
+    return entry.value.items.map((item) => composerString(item, 'footers', item.line, ignoreCase));
+}
 function placeholderStyleOf(entry) {
     const text = stringOf(entry.value);
     if (text !== 'dim')
@@ -233,10 +511,19 @@ function chromeOf(node) {
 }
 function regexField(entries, key, line, ignoreCase = false) {
     const entry = required(entries, key, line);
-    const text = stringOf(entry.value);
+    return composerString(entry.value, key, entry.line, ignoreCase);
+}
+// A composer key that reads a pattern string. The dialog shape aims its flag at the one
+// line it sits on; a composer's own patterns — its prompt, rule, footers, status line,
+// suffix — are strings, and the flag among them is refused in words that name the key.
+function composerString(node, key, line, ignoreCase = false) {
+    if (node.kind === 'map' && node.entries.some((item) => item.key === 'ignore_case')) {
+        fail(line, `"${key}" cannot ignore case: only a dialog pattern may`);
+    }
+    const text = stringOf(node);
     if (text === null)
-        fail(entry.line, `"${key}" must be a string`);
-    return patternOf(text, ignoreCase, entry.line);
+        fail(line, `"${key}" must be a string`);
+    return patternOf(text, ignoreCase, line);
 }
 function patternOf(text, ignoreCase, line) {
     try {

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

@@ -0,0 +1,19 @@
+import type { Screen } from './screen.ts';
+export type ComposerReading = {
+    kind: Screen['kind'];
+    from?: number;
+    input?: number;
+};
+/**
+ * Every hatch predicate is monotone toward caution, running alongside the data stage for unknown, trust, permission, question, and working so a hatch can only add caution, never remove it.
+ * A composer comes from data or from the hatch, never both, and a profile that has a data composer while its screen_module exports a composer is refused at load.
+ * The guarantees cover what a hatch returns and what load accepts; a hatch is trusted package code, not a sandbox.
+ */
+export interface ScreenProfile {
+    unknown?: (lines: string[]) => boolean;
+    trust?: (lines: string[]) => boolean;
+    permission?: (lines: string[]) => boolean;
+    question?: (lines: string[]) => boolean;
+    working?: (lines: string[]) => boolean;
+    composer?: (lines: string[]) => ComposerReading;
+}

package/dist/watch/screen-profile.js

@@ -0,0 +1 @@
+export {};

package/dist/watch/screen.d.ts

@@ -1,3 +1,6 @@
+import { type Box, type Fold } from './screen-core.ts';
+import type { ScreenData } from './screen-data.ts';
+export type { Box, Fold };
 export type Screen = {
     kind: 'idle';
 } | {
@@ -13,13 +16,28 @@ export type Screen = {
 } | {
     kind: 'unknown';
 };
+/** The shipped screen for a CLI, or null when this version has none. */
+export declare function screenData(cli: string): ScreenData | null;
+/** The same classification `classify` runs, against a screen that may carry added patterns. */
+export declare function classifyData(data: ScreenData, lines: string[]): Screen;
 /** Every stage, in the core's order. The first one that matches wins. */
-export declare function classify(cli: string, lines: string[]): Screen;
+export declare function classify(cli: string | ScreenData, lines: string[]): Screen;
 /** The composer alone. A running turn would otherwise hide an empty input box. */
-export declare function classifyComposer(cli: string, lines: string[]): Screen;
-export declare function readScreen(cli: string, screen: string | undefined): Screen;
+export declare function classifyComposer(cli: string | ScreenData, lines: string[]): Screen;
+export declare function readScreen(cli: string | ScreenData, screen: string | undefined): Screen;
+/** The folded form of a paste the pane's composer shows, or null. The shape only; the caller
+ *  verifies it holds the text it typed before trusting it. */
+export declare function readFold(cli: string | ScreenData, screen: string | undefined): Fold | null;
+/** Whether the pane shows a fold marker at all, whatever count it names. The case `readFold`
+ *  cannot report — a marker claiming zero hidden rows — must still keep an Enter from taking the
+ *  box for an ordinary unsent one. */
+export declare function readFoldMark(cli: string, screen: string | undefined): boolean;
+/** The input box the composer draws for its current text, or null when it does not read `unsent`.
+ *  The box's rows are the rows the pane drew for the text; the caller compares them to the text
+ *  it typed before any Enter. */
+export declare function readBox(cli: string, screen: string | undefined): Box | null;
 /** The one line a quota figure may come from: the composer's own status row, in the pane's last
  * 20 lines, read plain — a figure is never styled. Null for a CLI with no status line, and for
  * a window that shows no status row — a dialog, a question, a trust screen, a shell or an
  * unknown one reads no figures. */
-export declare function statusRow(cli: string, screen: string | undefined): string | null;
+export declare function statusRow(cli: string | ScreenData, screen: string | undefined): string | null;