@gaunt-sloth/core 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/runtime/askStructured.d.ts

@@ -65,6 +65,28 @@ export type StructuredFailureKind = 'timeout' | 'unparseable' | 'call-failed';
  *   carries it, so a different value here reports a genuine timeout as `call-failed`.
  */
 export declare function classifyStructuredFailure(error: string, timeoutMs: number): StructuredFailureKind;
+/**
+ * Say WHICH of {@link askStructured}'s three failures happened, in one sentence a reader can act on.
+ *
+ * The two a reader has to tell apart first are a provider that never answered and a provider that
+ * refused the request: they want opposite responses — re-run the one, investigate the other — and
+ * from the outside they arrive as the same red. Naming the class is what stops a real rejection
+ * being shrugged off as flakiness, which is how a guard stops guarding with nobody deciding to
+ * remove it.
+ *
+ * There is no `default` arm and no fallback sentence, deliberately. The module-internal
+ * `STRUCTURED_FAILURE_SENTENCES` map, declared above, is typed by the union, so an unhandled kind
+ * cannot reach here — the compiler rejects the map instead. A defensive arm would only catch a case
+ * the build already refuses, at the price of hiding the compile error that is the real signal.
+ * It is named here rather than linked because it is not exported, and a `{@link}` to an
+ * undocumented symbol renders as dead text in the API reference.
+ *
+ * @param error The `error` from a `{ ok: false }` {@link AskStructuredResult}.
+ * @param timeoutMs The budget passed to that same {@link askStructured} call — as for
+ *   {@link classifyStructuredFailure}, a different value here reports a genuine timeout as
+ *   `call-failed`.
+ */
+export declare function describeStructuredFailure(error: string, timeoutMs: number): string;
 /** Inputs to {@link askStructured}. The caller supplies the model (via config), the two message
  * texts, and an optional timeout — the Zod schema is a separate positional argument so `<T>` can
  * be inferred from it. */

package/dist/runtime/askStructured.js

@@ -64,6 +64,59 @@ export function classifyStructuredFailure(error, timeoutMs) {
         return 'unparseable';
     return 'call-failed';
 }
+/**
+ * The sentence each {@link StructuredFailureKind} is reported as — the wording a reader of a red run
+ * actually sees, and the half of {@link describeStructuredFailure} that can be wrong without any
+ * mechanism being wrong.
+ *
+ * It lives here, beside the classifier it is keyed on, for two reasons that are really one. The
+ * `Record` is annotated with the union, so the compiler checks the map is **total at its definition
+ * site**: adding a kind to {@link StructuredFailureKind} without giving it a sentence is a build
+ * error rather than a message that reads `undefined` at the moment someone needs it. And a sentence
+ * that sits beside the classifier is reachable by the unit suite, so each one is pinned to the class
+ * it names — a map the tests cannot see can have its bodies exchanged, and the failure that results
+ * is a stall announcing itself as a rejection, which is the exact confusion these sentences exist to
+ * end.
+ *
+ * Each entry receives the raw `error` and the budget the call was made with, so the sentence can
+ * quote both rather than describe them.
+ */
+const STRUCTURED_FAILURE_SENTENCES = {
+    timeout: (error, timeoutMs) => `STALLED: the provider returned no response within the ${timeoutMs}ms call budget. ` +
+        'Nothing was rejected and nothing was parsed, so this is NOT the schema guard firing — it ' +
+        'is the provider failing to answer. ' +
+        `askStructured said: ${error}`,
+    unparseable: (error) => "REJECTED BY OUR OWN SCHEMA: the provider answered, and the answer failed this case's " +
+        'schema. This IS the guard firing — the null-vs-absent half. ' +
+        `askStructured said: ${error}`,
+    'call-failed': (error) => 'REJECTED BEFORE ANY ANSWER: the call failed outright. A 400 naming `required` IS the ' +
+        'guard firing — the strict-schema half; anything else is auth, transport or configuration. ' +
+        `askStructured said: ${error}`,
+};
+/**
+ * Say WHICH of {@link askStructured}'s three failures happened, in one sentence a reader can act on.
+ *
+ * The two a reader has to tell apart first are a provider that never answered and a provider that
+ * refused the request: they want opposite responses — re-run the one, investigate the other — and
+ * from the outside they arrive as the same red. Naming the class is what stops a real rejection
+ * being shrugged off as flakiness, which is how a guard stops guarding with nobody deciding to
+ * remove it.
+ *
+ * There is no `default` arm and no fallback sentence, deliberately. The module-internal
+ * `STRUCTURED_FAILURE_SENTENCES` map, declared above, is typed by the union, so an unhandled kind
+ * cannot reach here — the compiler rejects the map instead. A defensive arm would only catch a case
+ * the build already refuses, at the price of hiding the compile error that is the real signal.
+ * It is named here rather than linked because it is not exported, and a `{@link}` to an
+ * undocumented symbol renders as dead text in the API reference.
+ *
+ * @param error The `error` from a `{ ok: false }` {@link AskStructuredResult}.
+ * @param timeoutMs The budget passed to that same {@link askStructured} call — as for
+ *   {@link classifyStructuredFailure}, a different value here reports a genuine timeout as
+ *   `call-failed`.
+ */
+export function describeStructuredFailure(error, timeoutMs) {
+    return STRUCTURED_FAILURE_SENTENCES[classifyStructuredFailure(error, timeoutMs)](error, timeoutMs);
+}
 /**
  * Ask the configured model for a single schema-validated object — a non-agentic structured-output
  * call that mirrors their mechanism (see the module doc) and never throws.

package/dist/runtime/askStructured.js.map

@@ -1 +1 @@
-{"version":3,"file":"askStructured.js","sourceRoot":"","sources":["../../src/runtime/askStructured.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"askStructured.js","sourceRoot":"","sources":["../../src/runtime/askStructured.ts"],"names":[],"mappings":"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"}

package/dist/utils/aiignoreUtils.d.ts

@@ -11,6 +11,12 @@
 export declare function loadAiignorePatterns(rootDir: string): string[];
 /**
  * Check if a file path should be ignored based on aiignore patterns
+ *
+ * Matching follows `.gitignore` rules — a bare pattern applies at every depth, a pattern with a
+ * separator is anchored to `rootDir`, and either kind hides the subtree beneath whatever it
+ * matches. The module-private `expandPattern` above implements that mapping and documents the two
+ * deliberate departures from `.gitignore`.
+ *
  * @param filePath - The file path to check
  * @param rootDir - The root directory for relative pattern matching
  * @param customPatterns - Optional custom patterns to use instead of loading from file

package/dist/utils/aiignoreUtils.js

@@ -32,8 +32,72 @@ export function loadAiignorePatterns(rootDir) {
         return [];
     }
 }
+/**
+ * Expand one `.aiignore` line into the glob patterns that implement it.
+ *
+ * `.aiignore` is documented as using `.gitignore` rules, and that is the contract this function
+ * keeps. `path.matchesGlob` on its own does not: its `*` never crosses `/`, so a bare pattern is
+ * silently root-only, and a trailing slash matches nothing at all. Both failures are silent and
+ * both point the wrong way for a privacy boundary — the user writes a line, sees no error, and
+ * believes a file is hidden from the agent when it is not.
+ *
+ * The three rules, each mapping to one arm below:
+ *
+ * - **A pattern with no separator applies at every depth.** `*.log` hides `app.log` and
+ *   `sub/app.log` alike, so it gains a globstar prefix. That prefixed form also matches at the
+ *   root, so the one arm covers both depths.
+ * - **A pattern containing a separator is anchored to the root.** `build/out` hides
+ *   `build/out`, never `src/build/out`. A leading `/` is an explicit spelling of the same thing and
+ *   is stripped, since relative paths never carry one.
+ * - **Whatever a pattern hides, it hides the subtree beneath it.** This is the `/**` arm, and it is
+ *   what makes a single line hide a directory's name *and* its contents. Without it the name is
+ *   withheld from a listing while every file below it stays readable — the shape of the leak this
+ *   boundary exists to prevent.
+ *
+ * DELIBERATE DEVIATION: a trailing slash is treated as an ordinary pattern rather than as
+ * "directories only", so `dist/` also hides a plain *file* named `dist`. Honouring the
+ * directory-only half needs the entry's type, which a path string does not carry and which the
+ * callers do not supply. Erring toward hiding costs a rare false positive the user can see and
+ * rename around; erring the other way silently exposes what someone asked to be hidden.
+ *
+ * NOT SUPPORTED: re-inclusion (`!pattern`). A leading `!` is matched literally, so such a line
+ * hides a file whose name really does start with `!` and un-hides nothing. That is the safe
+ * direction, and it is stated in the user documentation rather than left to be discovered.
+ *
+ * @param pattern - One non-empty, non-comment line from `.aiignore` or `aiignore.patterns`
+ * @returns Glob patterns to test the relative path against; empty when the line carries no pattern
+ */
+function expandPattern(pattern) {
+    // A trailing slash is gitignore's directory marker; strip it (see DELIBERATE DEVIATION above).
+    let body = pattern.replace(/\/+$/, '');
+    // A leading slash anchors to the root. Relative paths never carry one, so it must come off or
+    // the pattern matches nothing.
+    let anchored = false;
+    if (body.startsWith('/')) {
+        body = body.replace(/^\/+/, '');
+        anchored = true;
+    }
+    // A line that was nothing but slashes carries no pattern. Returning no arms is what keeps it
+    // from collapsing into `**`, which would hide the entire tree.
+    if (body.length === 0) {
+        return [];
+    }
+    // An interior separator anchors the pattern; its absence lets it apply at any depth.
+    if (body.includes('/')) {
+        anchored = true;
+    }
+    const base = anchored ? body : `**/${body}`;
+    // The entry itself, then everything beneath it.
+    return [base, `${base}/**`];
+}
 /**
  * Check if a file path should be ignored based on aiignore patterns
+ *
+ * Matching follows `.gitignore` rules — a bare pattern applies at every depth, a pattern with a
+ * separator is anchored to `rootDir`, and either kind hides the subtree beneath whatever it
+ * matches. The module-private `expandPattern` above implements that mapping and documents the two
+ * deliberate departures from `.gitignore`.
+ *
  * @param filePath - The file path to check
  * @param rootDir - The root directory for relative pattern matching
  * @param customPatterns - Optional custom patterns to use instead of loading from file
@@ -54,7 +118,11 @@ export function shouldIgnoreFile(filePath, rootDir, customPatterns = undefined,
     // Check if any pattern matches
     for (const pattern of patterns) {
         try {
-            if (path.matchesGlob(relativePath, pattern)) {
+            // Globs are built with `/` separators regardless of platform: win32's matchesGlob resolves a
+            // backslash-separated path against them, so the relative path is passed through untouched
+            // rather than rewritten (a rewrite would split a POSIX filename that legitimately contains a
+            // backslash into two segments).
+            if (expandPattern(pattern).some((glob) => path.matchesGlob(relativePath, glob))) {
                 debugLog(`File ignored by pattern '${pattern}': ${relativePath}`);
                 return true;
             }

package/dist/utils/aiignoreUtils.js.map

@@ -1 +1 @@
-{"version":3,"file":"aiignoreUtils.js","sourceRoot":"","sources":["../../src/utils/aiignoreUtils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"aiignoreUtils.js","sourceRoot":"","sources":["../../src/utils/aiignoreUtils.ts"],"names":[],"mappings":"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"}

package/dist/utils/displayWidth.d.ts

@@ -1,8 +1,8 @@
 /**
  * Terminal columns `text` occupies. Zero-width clusters (combining marks, default-ignorables)
  * count 0, wide clusters (CJK, emoji, fullwidth forms) count 2, everything else 1. ANSI escape
- * sequences are not counted, so a pre-coloured string measures as what the user sees — but the
- * slices below do not share that awareness, so do not read this as a licence to feed them one.
+ * sequences are not counted, so a pre-coloured string measures as what the user sees — and the
+ * slices below share that awareness, so a coloured string may be handed to either of them.
  */
 export declare function displayWidth(text: string): number;
 /**
@@ -46,8 +46,13 @@ export declare function sliceToMaxWidth(text: string, maxWidth: number): string;
  * the tail, lose the head. The mirror of {@link sliceToWidth}, for values whose end is the
  * informative part (a path's leaf directory).
  *
- * This one materialises the clusters: it walks backwards, and cluster boundaries are only
- * derivable from the front. Its callers pass a path or a model id, so the input is a line rather
- * than a file.
+ * This one materialises the pieces: it walks backwards, and both cluster and sequence boundaries
+ * are only derivable from the front. Its callers pass a path or a model id, so the input is a line
+ * rather than a file.
+ *
+ * Keeping the END means the escapes that OPENED a style sit in the discarded head and go with it,
+ * so a tail comes back in the terminal's default styling. Only the sequences inside the kept span
+ * are carried, which leaves the tail ending in whatever state the whole string ended in — the cut
+ * introduces no bleed of its own.
  */
 export declare function sliceEndToWidth(text: string, maxWidth: number): string;

package/dist/utils/displayWidth.js

@@ -23,24 +23,38 @@
  * rules below are defined over, so the two agree by construction and a sliced string's width is
  * exactly the sum of the widths of the clusters kept.
  *
- * ## What the slices expect: PLAIN text
- *
- * {@link displayWidth} is ANSI-aware and the slices are NOT, and that asymmetry is a contract
- * rather than an oversight. An escape sequence is not one cluster — the terminal swallows it
- * whole, but `ESC`, `[`, `3`, `5`, `m` segment as five, four of them printable — so the two
- * disagree on an escape-bearing string and a slice can both under-fill its budget and cut inside
- * a sequence. Feed the slices the text a user will read, and colour it afterwards; that is what
- * every caller here does, since both render surfaces map a style tag to their own escapes at the
- * very end. Making the slices ANSI-aware would change what a coloured preview line renders as,
- * which is a decision for whoever needs it and not a silent detail of this module.
- *
- * That asymmetry is also why a slice decides "does the whole string fit?" two different ways. For
- * plain text the cluster walk decides it: the widths of the clusters sum to the width of the
- * string, so walking until the budget is blown answers the question and answers it WITHOUT
- * touching the rest of the input — which is what keeps a megabyte-long preview line from being
- * measured end to end before it is cut at column 200. Only escape-bearing text is measured whole
- * first, because there the two rulers disagree and a coloured string that MEASURES as fitting must
- * be handed back whole rather than cut short by the bytes of its own escapes.
+ * ## What the slices cut: text, with its escapes carried along
+ *
+ * The slices are ANSI-aware, and they agree with {@link displayWidth} by construction. An escape
+ * sequence is not one cluster — the terminal swallows it whole, but `ESC`, `[`, `3`, `5`, `m`
+ * segment as five, four of them printable. A walk that spent budget on those printable bytes
+ * would answer a different question from the ruler it is paired with, since `string-width` strips
+ * escapes before measuring; and at a budget narrower than the content it would cut INSIDE a
+ * sequence, handing the terminal a mutilated escape.
+ *
+ * So a sequence is an indivisible token costing zero columns. It is kept whole, and it is carried
+ * along with the text it introduces, so a truncated coloured string still renders coloured. A
+ * sequence whose text is entirely cut away is dropped with that text rather than left dangling at
+ * the end of the result, where it would style nothing and leak its colour into whatever the caller
+ * appends next — an ellipsis, the next parameter, the status tag.
+ *
+ * **The result stays a genuine prefix (or suffix) of the input: no reset is appended.** Terminal
+ * state belongs to the surface that owns the line, and both render surfaces already open and close
+ * their own styling around each line they draw; an `ESC[0m` injected at the cut would close that
+ * wrapper early and un-style everything after it.
+ *
+ * Because escapes cost no budget, the clusters kept sum to the width of the string as
+ * {@link displayWidth} measures it, so the cluster walk decides "does the whole string fit?" on
+ * its own — incrementally, stopping at the budget, WITHOUT a pre-measurement of the input. That is
+ * what keeps a megabyte-long preview line from being measured end to end before it is cut at
+ * column 200, and it is why the escape-bearing case needs no separate ruler.
+ *
+ * The one input the two do not agree on is an escape sequence placed INSIDE a grapheme cluster,
+ * between a base character and its combining mark. The measurement strips the sequence and joins
+ * what is left into one cluster; the walk cannot, because the sequence has already broken the
+ * cluster in two. The walk then counts such a string WIDER than it renders, which spends budget
+ * that is not needed and can leave a slice short — never over its budget, which is the direction
+ * that matters.
  *
  * ## Why ambiguous-width characters stay NARROW — and the one place they must not
  *
@@ -75,8 +89,8 @@ const GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, { granularity: 'graphem
 /**
  * Terminal columns `text` occupies. Zero-width clusters (combining marks, default-ignorables)
  * count 0, wide clusters (CJK, emoji, fullwidth forms) count 2, everything else 1. ANSI escape
- * sequences are not counted, so a pre-coloured string measures as what the user sees — but the
- * slices below do not share that awareness, so do not read this as a licence to feed them one.
+ * sequences are not counted, so a pre-coloured string measures as what the user sees — and the
+ * slices below share that awareness, so a coloured string may be handed to either of them.
  */
 export function displayWidth(text) {
     return stringWidth(text);
@@ -104,22 +118,78 @@ export function firstCluster(text) {
         return segment;
     return '';
 }
-/** The clusters of `text`, in order — the only unit either slice is allowed to cut between. */
-function clusters(text) {
-    const out = [];
-    for (const { segment } of GRAPHEME_SEGMENTER.segment(text))
-        out.push(segment);
-    return out;
-}
 /**
- * Whether the whole-string measurement is the only ruler that can answer "does this fit" for
- * `text` — true exactly when it carries an escape introducer (`ESC`, or the one-byte `CSI`), the
- * two characters `string-width` itself strips on. On anything else the cluster widths sum to the
- * whole-string width, so the walk decides the same question incrementally and a pre-measurement
- * would be a second full pass over the input for nothing.
+ * The code points a sequence can begin with: `ESC` (U+001B) and the one-byte `CSI` (U+009B) — the
+ * same two characters `string-width` itself tests for before it strips.
+ */
+const ESCAPE_INTRODUCER_CODES = new Set([0x00_1b, 0x00_9b]);
+/**
+ * One ANSI escape sequence — an OSC string, or a CSI/two-character sequence — as a source pattern.
+ *
+ * This is the grammar of `ansi-regex`, which is what `strip-ansi` matches with and therefore what
+ * `string-width` removes before it measures. It is reproduced here rather than imported so the walk
+ * can never end up on a DIFFERENT copy of that package from the one `string-width` resolves: two
+ * versions in one tree would let the ruler and the walk disagree about where a sequence ends, which
+ * is the exact defect this module's ANSI-awareness exists to prevent. The spec cross-checks this
+ * pattern against `strip-ansi` itself, so a divergence fails loudly rather than silently.
+ *
+ * The OSC payload stops at the first terminator character instead of scanning ahead for one, so an
+ * unterminated OSC introducer cannot rescan the rest of the input — which is what keeps the walk
+ * linear on a long line full of half-written escapes rather than quadratic.
+ */
+const ANSI_SEQUENCE_SOURCE = [
+    '(?:\\u001B\\][^\\u0007\\u001B\\u009C]*(?:\\u0007|\\u001B\\u005C|\\u009C))',
+    '[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]',
+].join('|');
+/**
+ * The same grammar anchored with the sticky flag, so it answers "does a sequence START here?" in
+ * one step at a known index rather than searching forward for the next one anywhere in the string.
+ *
+ * Module-level, because compiling it per slice would tax the common case that never uses it. Its
+ * `lastIndex` is written immediately before every `exec`, with nothing in between, so a second walk
+ * that begins while the first is suspended cannot observe a stale position.
  */
-function needsWholeStringMeasure(text) {
-    return text.includes('\u001B') || text.includes('\u009B');
+const ANSI_SEQUENCE_AT_INDEX = new RegExp(ANSI_SEQUENCE_SOURCE, 'y');
+/**
+ * The pieces of `text` in order — whole escape sequences and whole grapheme clusters, the only
+ * units either slice is allowed to cut between.
+ *
+ * Lazy, and that is the point: the head slice stops pulling at its budget, so a megabyte-long line
+ * costs the length of the RESULT rather than the length of the input.
+ *
+ * An escape introducer is always its own cluster, because the segmentation rules break on both
+ * sides of a control character — so a sequence can only ever begin where a cluster begins, and one
+ * anchored match there settles how far it runs. The clusters it spans are then skipped. A cluster
+ * that STRADDLES the end of a sequence (a combining mark binding to the sequence's final byte)
+ * yields only the part beyond it, so the pieces always reassemble into the input exactly.
+ */
+function* widthTokens(text) {
+    let index = 0;
+    for (const { segment, index: at } of GRAPHEME_SEGMENTER.segment(text)) {
+        const end = at + segment.length;
+        if (end <= index)
+            continue; // wholly inside a sequence already yielded
+        if (at < index) {
+            // Straddles the end of that sequence: only what lies beyond it is still unyielded.
+            const rest = text.slice(index, end);
+            index = end;
+            yield { text: rest, escape: false };
+            continue;
+        }
+        if (segment.length === 1 && ESCAPE_INTRODUCER_CODES.has(segment.charCodeAt(0))) {
+            ANSI_SEQUENCE_AT_INDEX.lastIndex = at;
+            const match = ANSI_SEQUENCE_AT_INDEX.exec(text);
+            if (match !== null) {
+                index = at + match[0].length;
+                yield { text: match[0], escape: true };
+                continue;
+            }
+            // An introducer that begins no sequence falls through as an ordinary cluster. It is a
+            // control character, so it measures zero and costs no budget either way.
+        }
+        index = end;
+        yield { text: segment, escape: false };
+    }
 }
 /**
  * The longest LEADING run of whole clusters whose total width is at most `maxWidth` — i.e. keep
@@ -146,50 +216,74 @@ export function sliceToMaxWidth(text, maxWidth) {
 }
 /**
  * The head-slice both public cuts are made of, given the ruler to measure with. The ruler is passed
- * rather than chosen here so the whole-string shortcut and the cluster walk can never end up on
- * different ones — measuring the shortcut narrow and the walk wide would hand back a string that
- * overruns the very budget the caller asked to be held to.
+ * rather than chosen here so a caller cannot end up measured by one and cut by the other — reading
+ * the budget narrow and spending it wide would hand back a string that overruns the very budget the
+ * caller asked to be held to.
+ *
+ * The input is measured ONCE, incrementally, by the walk itself: escapes cost nothing, so the
+ * clusters kept sum to what {@link displayWidth} would report for them, and "does the whole string
+ * fit?" is answered by reaching the end rather than by a separate pass over the input first.
+ *
+ * Escapes are held back until a cluster is actually kept, so a sequence whose text all falls
+ * outside the budget is dropped with it instead of trailing the result and colouring whatever the
+ * caller appends next.
  */
 function sliceHeadToWidth(text, maxWidth, measure) {
     if (maxWidth <= 0)
         return '';
-    if (needsWholeStringMeasure(text) && measure(text) <= maxWidth)
-        return text;
     let width = 0;
     let kept = '';
-    for (const { segment } of GRAPHEME_SEGMENTER.segment(text)) {
-        const clusterWidth = measure(segment);
+    let pendingEscapes = '';
+    for (const token of widthTokens(text)) {
+        if (token.escape) {
+            pendingEscapes += token.text;
+            continue;
+        }
+        const clusterWidth = measure(token.text);
         if (width + clusterWidth > maxWidth)
-            break;
+            return kept;
         width += clusterWidth;
-        kept += segment;
+        kept += pendingEscapes + token.text;
+        pendingEscapes = '';
     }
-    return kept;
+    // Every token fitted, so the answer is the input itself — returned rather than reassembled, so
+    // a caller comparing the result with what it passed in gets the identity it is testing for.
+    return text;
 }
 /**
  * The longest TRAILING run of whole clusters whose total width is at most `maxWidth` — i.e. keep
  * the tail, lose the head. The mirror of {@link sliceToWidth}, for values whose end is the
  * informative part (a path's leaf directory).
  *
- * This one materialises the clusters: it walks backwards, and cluster boundaries are only
- * derivable from the front. Its callers pass a path or a model id, so the input is a line rather
- * than a file.
+ * This one materialises the pieces: it walks backwards, and both cluster and sequence boundaries
+ * are only derivable from the front. Its callers pass a path or a model id, so the input is a line
+ * rather than a file.
+ *
+ * Keeping the END means the escapes that OPENED a style sit in the discarded head and go with it,
+ * so a tail comes back in the terminal's default styling. Only the sequences inside the kept span
+ * are carried, which leaves the tail ending in whatever state the whole string ended in — the cut
+ * introduces no bleed of its own.
  */
 export function sliceEndToWidth(text, maxWidth) {
     if (maxWidth <= 0)
         return '';
-    if (needsWholeStringMeasure(text) && displayWidth(text) <= maxWidth)
-        return text;
-    const all = clusters(text);
+    const all = [...widthTokens(text)];
     let width = 0;
     let kept = '';
+    let pendingEscapes = '';
     for (let index = all.length - 1; index >= 0; index--) {
-        const clusterWidth = displayWidth(all[index]);
+        const token = all[index];
+        if (token.escape) {
+            pendingEscapes = token.text + pendingEscapes;
+            continue;
+        }
+        const clusterWidth = displayWidth(token.text);
         if (width + clusterWidth > maxWidth)
-            break;
+            return kept;
         width += clusterWidth;
-        kept = all[index] + kept;
+        kept = token.text + pendingEscapes + kept;
+        pendingEscapes = '';
     }
-    return kept;
+    return text;
 }
 //# sourceMappingURL=displayWidth.js.map

package/dist/utils/displayWidth.js.map

@@ -1 +1 @@
-{"version":3,"file":"displayWidth.js","sourceRoot":"","sources":["../../src/utils/displayWidth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,OAAO,WAAW,MAAM,cAAc,CAAC;AAEvC;;;GAGG;AACH,MAAM,kBAAkB,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;AAEtF;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC;AAC3B,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,OAAO,WAAW,CAAC,IAAI,EAAE,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC,CAAC;AACzD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,KAAK,MAAM,EAAE,OAAO,EAAE,IAAI,kBAAkB,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,OAAO,CAAC;IAC3E,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,+FAA+F;AAC/F,SAAS,QAAQ,CAAC,IAAY;IAC5B,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,KAAK,MAAM,EAAE,OAAO,EAAE,IAAI,kBAAkB,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC9E,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;GAMG;AACH,SAAS,uBAAuB,CAAC,IAAY;IAC3C,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY,EAAE,QAAgB;IACzD,OAAO,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC;AACxD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY,EAAE,QAAgB;IAC5D,OAAO,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,eAAe,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;GAKG;AACH,SAAS,gBAAgB,CACvB,IAAY,EACZ,QAAgB,EAChB,OAAiC;IAEjC,IAAI,QAAQ,IAAI,CAAC;QAAE,OAAO,EAAE,CAAC;IAC7B,IAAI,uBAAuB,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC5E,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,IAAI,GAAG,EAAE,CAAC;IACd,KAAK,MAAM,EAAE,OAAO,EAAE,IAAI,kBAAkB,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3D,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QACtC,IAAI,KAAK,GAAG,YAAY,GAAG,QAAQ;YAAE,MAAM;QAC3C,KAAK,IAAI,YAAY,CAAC;QACtB,IAAI,IAAI,OAAO,CAAC;IAClB,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY,EAAE,QAAgB;IAC5D,IAAI,QAAQ,IAAI,CAAC;QAAE,OAAO,EAAE,CAAC;IAC7B,IAAI,uBAAuB,CAAC,IAAI,CAAC,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,QAAQ;QAAE,OAAO,IAAI,CAAC;IACjF,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC3B,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,IAAI,GAAG,EAAE,CAAC;IACd,KAAK,IAAI,KAAK,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;QACrD,MAAM,YAAY,GAAG,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;QAC9C,IAAI,KAAK,GAAG,YAAY,GAAG,QAAQ;YAAE,MAAM;QAC3C,KAAK,IAAI,YAAY,CAAC;QACtB,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAC3B,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}
+{"version":3,"file":"displayWidth.js","sourceRoot":"","sources":["../../src/utils/displayWidth.ts"],"names":[],"mappings":"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"}

package/dist/utils/llmUtils.d.ts

@@ -32,7 +32,7 @@ export declare function readCodePrompt(config: PromptReadConfig): string;
 export declare function readExecPrompt(config: PromptReadConfig): string;
 /**
  * GS2-79 — the SINGLE place a command's mode prompt is chosen, for every site that composes a
- * system prompt via {@link buildSystemMessages}: both agent backends and the subagent profiles.
+ * system prompt via {@link buildSystemMessages}: the agent and the subagent profiles.
  *
  * It exists because the selection used to be an inline three-branch ternary copied to each of
  * those sites, and a command missing from one copy is silently served the CHAT prompt — the

package/dist/utils/llmUtils.js

@@ -117,7 +117,7 @@ export function readExecPrompt(config) {
 }
 /**
  * GS2-79 — the SINGLE place a command's mode prompt is chosen, for every site that composes a
- * system prompt via {@link buildSystemMessages}: both agent backends and the subagent profiles.
+ * system prompt via {@link buildSystemMessages}: the agent and the subagent profiles.
  *
  * It exists because the selection used to be an inline three-branch ternary copied to each of
  * those sites, and a command missing from one copy is silently served the CHAT prompt — the

package/dist/utils/systemPromptNotes.d.ts

@@ -93,9 +93,9 @@ export interface CommitCoAuthor {
  * it literally (the overwhelmingly common case, and a literal name is what makes the instruction
  * actionable); when it is not, the note names no tool, keeps both prohibitions and the file form,
  * and supplies the compliant path that remains: do not commit, and hand the message back to the
- * user. That branch states no availability claim of its own — the backends read the same
- * `filesystem` value but register filesystem tools differently, so a note asserting "you have no
- * file-writing tool" could be flatly false on one of them.
+ * user. That branch states no availability claim of its own — registering filesystem tools is the
+ * agent's decision, made from the same `filesystem` value, so a note asserting "you have no
+ * file-writing tool" could be flatly false.
  *
  * The note's prose carries **no backtick and no other markup** — including no angle-bracket
  * placeholder: it is the one piece of guidance whose subject is how to write a commit message, so

package/dist/utils/systemPromptNotes.js

@@ -117,9 +117,9 @@ export function appendCwdNote(systemPrompt, cwd) {
  * it literally (the overwhelmingly common case, and a literal name is what makes the instruction
  * actionable); when it is not, the note names no tool, keeps both prohibitions and the file form,
  * and supplies the compliant path that remains: do not commit, and hand the message back to the
- * user. That branch states no availability claim of its own — the backends read the same
- * `filesystem` value but register filesystem tools differently, so a note asserting "you have no
- * file-writing tool" could be flatly false on one of them.
+ * user. That branch states no availability claim of its own — registering filesystem tools is the
+ * agent's decision, made from the same `filesystem` value, so a note asserting "you have no
+ * file-writing tool" could be flatly false.
  *
  * The note's prose carries **no backtick and no other markup** — including no angle-bracket
  * placeholder: it is the one piece of guidance whose subject is how to write a commit message, so