@taurgis/bonsai 3.2.2 → 4.0.0

package/dist/lib/research/import-command-service.js

@@ -5,6 +5,7 @@ import { loadSummaryLevel } from '../config/index.js';
 import { buildCompressed } from './compress.js';
 import { durationFlagError, resolveFreshnessPolicy } from './freshness.js';
 import { applyAutoTags } from './keywords.js';
+import { metadataLengthError, metadataNewlineError } from './metadata-flags.js';
 import { persistArtifact } from './persist-artifact.js';
 import { sanitizePromptInjection } from './prompt-injection.js';
 import { getArtifactPath } from './storage.js';
@@ -14,6 +15,7 @@ import { deriveCacheKey } from './cache-key.js';
 import { normalizeUrl } from './url.js';
 import { failInvalidUrl } from './cli-io.js';
 import { formatHumanFields } from '../cli-presentation.js';
+import { sanitizeForTerminal } from '../text.js';
 const INPUT_LIMIT_BYTES = 1024 * 1024;
 // ponytail: 1s stdin idle timeout is enough for piped agent input; raise if interactive paste
 // workflows need longer before the read aborts.
@@ -29,6 +31,22 @@ export async function prepareImportCommandService(opts) {
     const ttlErr = durationFlagError('--ttl', flags.ttl);
     if (ttlErr)
         io.error(ttlErr, { exit: 2, code: 'INVALID_DURATION' });
+    const newlineErr = metadataNewlineError(flags);
+    if (newlineErr) {
+        io.error(newlineErr, {
+            exit: 2,
+            code: 'INVALID_METADATA_VALUE',
+            suggestions: ['Remove line breaks from the value.'],
+        });
+    }
+    const lengthErr = metadataLengthError(flags);
+    if (lengthErr) {
+        io.error(lengthErr, {
+            exit: 2,
+            code: 'INVALID_METADATA_VALUE',
+            suggestions: ['Shorten the value.'],
+        });
+    }
     validateSourceMode(hasSingle, hasMulti, flags, io);
     const rawInput = await readAndValidateInput(flags, input, io);
     const sourceUrls = getSourceUrls(hasMulti, flags.sourceUrls, args.url, io);
@@ -128,9 +146,12 @@ function logImportHumanSuccess(io, opts) {
         ['Cache Key', cacheKey],
         ['Storage Path', storagePath],
     ];
+    // The agent-supplied --topic is untrusted the same way fetched content is (it may be lifted
+    // straight from a page an agent just read), so it gets the same terminal sanitization as
+    // list/inspect/prune apply to a cached topic before printing it.
     let topic;
     if (!hasSingle) {
-        topic = resolvedTopic(flags);
+        topic = sanitizeForTerminal(resolvedTopic(flags));
         fields.push(['Topic', topic], ['Source URLs', sourceUrls.join(', ')]);
     }
     for (const line of formatHumanFields(fields))

package/dist/lib/research/metadata-filters.d.ts

@@ -0,0 +1,18 @@
+import type { ResearchArtifactMetadata } from './schema.js';
+/** Whether an artifact's topic matches a `--topic` filter (case-insensitive exact match). */
+export declare function matchesTopicFilter(meta: Pick<ResearchArtifactMetadata, 'topic'>, topic: string | undefined): boolean;
+/** Whether an artifact's tags satisfy a `--tags` filter (case-insensitive, must match all). */
+export declare function matchesTagsFilter(meta: Pick<ResearchArtifactMetadata, 'tags'>, tags: string[] | undefined): boolean;
+/**
+ * Reject an explicitly passed, whitespace-only `--topic` filter. Silently treating it as "no
+ * filter" (matching everything, as an empty/falsy value normally would in {@link matchesTopicFilter})
+ * would hide what's almost always a shell-quoting mistake — the same reasoning `--url` already
+ * applies via `emptyUrlFilterError`.
+ */
+export declare function emptyTopicFilterError(topic: string | undefined): string | undefined;
+/**
+ * Reject an explicitly passed, whitespace-only `--tags` filter entry. Unlike a missing/empty
+ * `--topic` (which reads as "no filter"), an empty tag string in {@link matchesTagsFilter} never
+ * matches any artifact's tags — silently returning zero results with no signal. Fail fast instead.
+ */
+export declare function emptyTagsFilterError(tags: string[] | undefined): string | undefined;

package/dist/lib/research/metadata-filters.js

@@ -0,0 +1,37 @@
+/** Whether an artifact's topic matches a `--topic` filter (case-insensitive exact match). */
+export function matchesTopicFilter(meta, topic) {
+    if (!topic)
+        return true;
+    return !!meta.topic && meta.topic.trim().toLowerCase() === topic.trim().toLowerCase();
+}
+/** Whether an artifact's tags satisfy a `--tags` filter (case-insensitive, must match all). */
+export function matchesTagsFilter(meta, tags) {
+    if (!tags || tags.length === 0)
+        return true;
+    const metaTagsLower = meta.tags.map((t) => t.toLowerCase());
+    return tags.every((t) => metaTagsLower.includes(t.toLowerCase()));
+}
+/**
+ * Reject an explicitly passed, whitespace-only `--topic` filter. Silently treating it as "no
+ * filter" (matching everything, as an empty/falsy value normally would in {@link matchesTopicFilter})
+ * would hide what's almost always a shell-quoting mistake — the same reasoning `--url` already
+ * applies via `emptyUrlFilterError`.
+ */
+export function emptyTopicFilterError(topic) {
+    if (topic === undefined)
+        return undefined;
+    if (topic.trim() === '') {
+        return '--topic must be a non-empty value (e.g. "React Suspense").';
+    }
+    return undefined;
+}
+/**
+ * Reject an explicitly passed, whitespace-only `--tags` filter entry. Unlike a missing/empty
+ * `--topic` (which reads as "no filter"), an empty tag string in {@link matchesTagsFilter} never
+ * matches any artifact's tags — silently returning zero results with no signal. Fail fast instead.
+ */
+export function emptyTagsFilterError(tags) {
+    if (!tags?.some((t) => t.trim() === ''))
+        return undefined;
+    return '--tags must be non-empty values (e.g. "react").';
+}

package/dist/lib/research/metadata-flags.d.ts

@@ -0,0 +1,34 @@
+/** Longest `--topic` value accepted; topics are short labels, not free text. */
+export declare const MAX_TOPIC_LENGTH = 200;
+/** Longest single `--tags` value accepted; tags are short taxonomic labels. */
+export declare const MAX_TAG_LENGTH = 100;
+/**
+ * Reject a `--topic`/`--tags` value longer than its cap before it ever reaches the cache.
+ * Unbounded input here would still round-trip through YAML frontmatter and `list`/`inspect`
+ * output correctly, but a single unreasonably long value wraps a human-readable listing line
+ * across dozens of terminal rows, so cap it at the flag boundary the same way `metadataNewlineError`
+ * catches the newline case.
+ *
+ * @param flags - The command's parsed `topic`/`tags` flags.
+ * @returns An error message naming the offending flag and its length cap, or `null` when both fit.
+ */
+export declare function metadataLengthError(flags: {
+    topic?: string;
+    tags?: string[];
+}): string | null;
+/**
+ * Reject a `--topic`/`--tags` value containing a line break before it ever reaches the cache.
+ * Stored as-is, an embedded newline would corrupt the single-line-per-field frontmatter format
+ * (see `sanitizeFrontmatterLine` in `artifact.ts`): at best a silently dropped stray line, at
+ * worst a spoofed `key: value` pair or a bare `---` that closes the frontmatter fence early and
+ * splices the rest of the metadata into the body. Failing fast here — rather than letting the
+ * serializer silently rewrite the caller's input — gives the same actionable-error treatment as
+ * every other flag validator (`durationFlagError`, etc.).
+ *
+ * @param flags - The command's parsed `topic`/`tags` flags.
+ * @returns An error message naming the offending flag, or `null` when both are clean.
+ */
+export declare function metadataNewlineError(flags: {
+    topic?: string;
+    tags?: string[];
+}): string | null;

package/dist/lib/research/metadata-flags.js

@@ -0,0 +1,45 @@
+/** Longest `--topic` value accepted; topics are short labels, not free text. */
+export const MAX_TOPIC_LENGTH = 200;
+/** Longest single `--tags` value accepted; tags are short taxonomic labels. */
+export const MAX_TAG_LENGTH = 100;
+/**
+ * Reject a `--topic`/`--tags` value longer than its cap before it ever reaches the cache.
+ * Unbounded input here would still round-trip through YAML frontmatter and `list`/`inspect`
+ * output correctly, but a single unreasonably long value wraps a human-readable listing line
+ * across dozens of terminal rows, so cap it at the flag boundary the same way `metadataNewlineError`
+ * catches the newline case.
+ *
+ * @param flags - The command's parsed `topic`/`tags` flags.
+ * @returns An error message naming the offending flag and its length cap, or `null` when both fit.
+ */
+export function metadataLengthError(flags) {
+    if (flags.topic !== undefined && flags.topic.length > MAX_TOPIC_LENGTH) {
+        return `--topic must be ${MAX_TOPIC_LENGTH} characters or fewer (got ${flags.topic.length}).`;
+    }
+    const longTag = flags.tags?.find((tag) => tag.length > MAX_TAG_LENGTH);
+    if (longTag !== undefined) {
+        return `--tags must be ${MAX_TAG_LENGTH} characters or fewer (got ${longTag.length}).`;
+    }
+    return null;
+}
+/**
+ * Reject a `--topic`/`--tags` value containing a line break before it ever reaches the cache.
+ * Stored as-is, an embedded newline would corrupt the single-line-per-field frontmatter format
+ * (see `sanitizeFrontmatterLine` in `artifact.ts`): at best a silently dropped stray line, at
+ * worst a spoofed `key: value` pair or a bare `---` that closes the frontmatter fence early and
+ * splices the rest of the metadata into the body. Failing fast here — rather than letting the
+ * serializer silently rewrite the caller's input — gives the same actionable-error treatment as
+ * every other flag validator (`durationFlagError`, etc.).
+ *
+ * @param flags - The command's parsed `topic`/`tags` flags.
+ * @returns An error message naming the offending flag, or `null` when both are clean.
+ */
+export function metadataNewlineError(flags) {
+    if (flags.topic !== undefined && /[\r\n]/.test(flags.topic)) {
+        return '--topic cannot contain line breaks.';
+    }
+    if (flags.tags?.some((tag) => /[\r\n]/.test(tag))) {
+        return '--tags cannot contain line breaks.';
+    }
+    return null;
+}

package/dist/lib/research/prompt-injection.d.ts

@@ -4,6 +4,7 @@
  * HTML comments are checked first; the body is then split on paragraph breaks and scanned line-by-line.
  *
  * @param markdown - Markdown content (possibly untrusted, sourced from fetched pages).
- * @returns Sanitized Markdown with harmful instruction blocks replaced by a redaction placeholder.
+ * @returns Sanitized Markdown with harmful instruction blocks replaced by a redaction placeholder,
+ *   and ANSI/control bytes stripped so a cached read can never replay them to a terminal.
  */
 export declare function sanitizePromptInjection(markdown: string): string;

package/dist/lib/research/prompt-injection.js

@@ -1,6 +1,20 @@
 import { Buffer } from 'node:buffer';
+import { CONTROL_CHAR_PATTERN } from '../text.js';
 const REDACTION = '[Removed potentially unsafe agent instruction]';
 const ZERO_WIDTH = /[\u200b-\u200f\ufeff]/g;
+// Tab/LF/CR fall inside CONTROL_CHAR_PATTERN's Unicode "Control" category too, but they are
+// legitimate Markdown whitespace, so the replacer below keeps those three and drops everything else.
+const SAFE_CONTROL_CHARS = new Set(['\t', '\n', '\r']);
+/**
+ * Removes ANSI escape codes and other control bytes a malicious page could embed in its visible
+ * text, while leaving Markdown-structural whitespace (tab/newline/CR) intact. Every fetch/import
+ * path renders its stored content directly to the terminal (`bonsai <url>`, cache hits, etc.), so
+ * raw control bytes surviving Readability/Turndown would replay as a terminal-injection attack on
+ * every subsequent read of the cache; this is the choke point all of those paths share.
+ */
+function stripUnsafeControlChars(text) {
+    return text.replace(CONTROL_CHAR_PATTERN, (char) => (SAFE_CONTROL_CHARS.has(char) ? char : ''));
+}
 const HTML_COMMENT = /<!--[\s\S]*?-->/g;
 const BASE64_TOKEN = /(?<![A-Za-z0-9+/_-])(?:[A-Za-z0-9+/_-]{16,}={0,2})(?![A-Za-z0-9+/_-])/g;
 const HEX_TOKEN = /(?<![a-f0-9])(?:0x)?[a-f0-9]{24,}(?![a-f0-9])/gi;
@@ -159,10 +173,11 @@ function stripQuotes(span) {
  * HTML comments are checked first; the body is then split on paragraph breaks and scanned line-by-line.
  *
  * @param markdown - Markdown content (possibly untrusted, sourced from fetched pages).
- * @returns Sanitized Markdown with harmful instruction blocks replaced by a redaction placeholder.
+ * @returns Sanitized Markdown with harmful instruction blocks replaced by a redaction placeholder,
+ *   and ANSI/control bytes stripped so a cached read can never replay them to a terminal.
  */
 export function sanitizePromptInjection(markdown) {
-    return markdown
+    const redacted = markdown
         .replace(HTML_COMMENT, (comment) => redactBlock(comment))
         .split(/(\n{2,})/)
         .map((block) => {
@@ -175,4 +190,5 @@ export function sanitizePromptInjection(markdown) {
         return lineRedacted === block ? redactBlock(block) : lineRedacted;
     })
         .join('');
+    return stripUnsafeControlChars(redacted);
 }

package/dist/lib/research/resolve-target.d.ts

@@ -7,6 +7,8 @@ export interface ResolveResearchTargetOptions {
     dataDir: string;
     flagOverride?: StorageMode;
     lookup?: boolean;
+    /** Read-only/plan mode: a corrupt entry hit during lookup is reported but never archived on disk. */
+    readOnly?: boolean;
     url: string;
 }
 export interface ResolvedResearchTarget {

package/dist/lib/research/resolve-target.js

@@ -13,7 +13,7 @@ export function resolveResearchTarget(opts) {
     });
     return {
         cacheKey,
-        located: opts.lookup === false ? null : locateArtifact(roots.readRoots, cacheKey),
+        located: opts.lookup === false ? null : locateArtifact(roots.readRoots, cacheKey, opts.readOnly),
         normalizedUrl,
         roots,
     };

package/dist/lib/research/storage.d.ts

@@ -13,13 +13,10 @@ export declare function getArtifactPath(dataDir: string, key: string): string;
 /**
  * Scans the research storage directory, reading metadata of all valid markdown files
  * to find the active artifact for the given cache key with the newest validated_at timestamp.
- * If a corrupt artifact is found, it is skipped and archived as corrupt.
+ * If a corrupt artifact is found, it is skipped and archived as corrupt — unless `readOnly` is set,
+ * in which case it is only reported, never renamed on disk.
  */
-export declare function findArtifact(dataDir: string, key: string): ResearchArtifact | null;
-/**
- * Checks if a cached artifact exists on disk for a given cache key.
- */
-export declare function hasArtifact(dataDir: string, key: string): boolean;
+export declare function findArtifact(dataDir: string, key: string, readOnly?: boolean): ResearchArtifact | null;
 /**
  * Writes a ResearchArtifact to disk, creating the research storage folder if needed.
  * Writes to a temporary file first, then atomically renames it.
@@ -42,7 +39,7 @@ export interface LocatedArtifact {
  * returning the first match along with where it lives. Implements the project→global
  * read fallback: a missing project entry still resolves against the global cache.
  */
-export declare function locateArtifact(dataDirs: string[], key: string): LocatedArtifact | null;
+export declare function locateArtifact(dataDirs: string[], key: string, readOnly?: boolean): LocatedArtifact | null;
 /**
  * Multi-root variant of {@link scanCacheDir}. Scans the `research/` dir of each data dir in
  * order and deduplicates by cache key so an entry present in an earlier root (project) shadows

package/dist/lib/research/storage.js

@@ -18,7 +18,14 @@ export function scanCacheDir(dir, fn) {
             continue;
         try {
             const content = readFileSync(join(dir, file), 'utf-8');
-            const result = fn(parseArtifact(content), join(dir, file));
+            const artifact = parseArtifact(content);
+            // parseArtifact defaults unrecognized frontmatter to a valid-looking shell (cache_key: '',
+            // status: 'active'), so a foreign or otherwise-garbled *.md file with `---`/`---` fences never
+            // throws here — it would otherwise surface as a phantom entry with no usable cache key. Every
+            // artifact Bonsai itself writes always has one, so an empty cache_key means "not ours."
+            if (!artifact.metadata.cache_key)
+                continue;
+            const result = fn(artifact, join(dir, file));
             if (result !== null)
                 results.push(result);
         }
@@ -36,7 +43,7 @@ export function getArtifactPath(dataDir, key) {
     }
     return join(dataDir, 'research', `${key}.md`);
 }
-function processFileForLookup(file, dir, key) {
+function processFileForLookup(file, dir, key, readOnly) {
     // Same file filter as scanCacheDir — superseded/corrupt/tmp archives must not resolve as active.
     if (!isResearchFile(file)) {
         return null;
@@ -51,13 +58,17 @@ function processFileForLookup(file, dir, key) {
     }
     catch (err) {
         console.warn(`Warning: Corrupt research artifact found at "${filePath}": ${err.message}`);
-        try {
-            const corruptPath = `${filePath}.corrupt.${Date.now()}`;
-            renameSync(filePath, corruptPath);
-            console.warn(`Archived corrupt artifact to "${corruptPath}"`);
-        }
-        catch (archiveErr) {
-            console.error(`Failed to archive corrupt artifact: ${archiveErr.message}`);
+        // Archiving renames the file on disk — a write a read-only/plan-mode lookup (e.g. `status`,
+        // `inspect --read-only`) must never perform, even incidentally while diagnosing a corrupt entry.
+        if (!readOnly) {
+            try {
+                const corruptPath = `${filePath}.corrupt.${Date.now()}`;
+                renameSync(filePath, corruptPath);
+                console.warn(`Archived corrupt artifact to "${corruptPath}"`);
+            }
+            catch (archiveErr) {
+                console.error(`Failed to archive corrupt artifact: ${archiveErr.message}`);
+            }
         }
     }
     return null;
@@ -65,9 +76,10 @@ function processFileForLookup(file, dir, key) {
 /**
  * Scans the research storage directory, reading metadata of all valid markdown files
  * to find the active artifact for the given cache key with the newest validated_at timestamp.
- * If a corrupt artifact is found, it is skipped and archived as corrupt.
+ * If a corrupt artifact is found, it is skipped and archived as corrupt — unless `readOnly` is set,
+ * in which case it is only reported, never renamed on disk.
  */
-export function findArtifact(dataDir, key) {
+export function findArtifact(dataDir, key, readOnly = false) {
     const dir = join(dataDir, 'research');
     if (!existsSync(dir)) {
         return null;
@@ -76,7 +88,7 @@ export function findArtifact(dataDir, key) {
     let bestValidatedAt = -1;
     const files = readdirSync(dir);
     for (const file of files) {
-        const artifact = processFileForLookup(file, dir, key);
+        const artifact = processFileForLookup(file, dir, key, readOnly);
         if (!artifact) {
             continue;
         }
@@ -90,17 +102,6 @@ export function findArtifact(dataDir, key) {
     }
     return bestArtifact;
 }
-/**
- * Checks if a cached artifact exists on disk for a given cache key.
- */
-export function hasArtifact(dataDir, key) {
-    try {
-        return findArtifact(dataDir, key) !== null;
-    }
-    catch {
-        return false;
-    }
-}
 /**
  * Writes a ResearchArtifact to disk, creating the research storage folder if needed.
  * Writes to a temporary file first, then atomically renames it.
@@ -149,9 +150,9 @@ export function readArtifact(dataDir, key) {
  * returning the first match along with where it lives. Implements the project→global
  * read fallback: a missing project entry still resolves against the global cache.
  */
-export function locateArtifact(dataDirs, key) {
+export function locateArtifact(dataDirs, key, readOnly = false) {
     for (const dataDir of dataDirs) {
-        const artifact = findArtifact(dataDir, key);
+        const artifact = findArtifact(dataDir, key, readOnly);
         if (artifact) {
             return { artifact, dataDir, path: getArtifactPath(dataDir, key) };
         }

package/dist/lib/text.d.ts

@@ -1,27 +1,33 @@
 /** Display label when an artifact has no topic — not a filterable topic value. */
 export declare const NO_TOPIC_LABEL = "(no topic)";
+export declare const CONTROL_CHAR_PATTERN: RegExp;
+/**
+ * Strip ANSI escape codes and other control characters from a cached metadata string before it
+ * reaches a human-readable terminal line. Fields like `topic` and section headings can originate
+ * from fetched web content or agent-supplied notes — both untrusted per the repo's trust-boundary
+ * rules — so a value containing raw escape bytes must never be echoed as-is to a TTY. Newlines and
+ * tabs collapse to a single space rather than being stripped outright, so injected content can't
+ * fake extra output lines while still being removed. JSON output is unaffected: `JSON.stringify`
+ * already escapes control characters, so this only needs to run on the human-readable path.
+ */
+export declare function sanitizeForTerminal(value: string): string;
 /**
  * Pick the singular or plural noun for a count so human-readable output stays grammatical
  * ("1 entry" / "2 entries"). English has irregular plurals, so the plural is passed explicitly
  * rather than derived.
  */
 export declare function pluralize(count: number, singular: string, plural: string): string;
-/** How a command labels a result listing, so its heading and truncation notice stay consistent. */
+/** Shared "Tip: " prefix for contextual next-step suggestions in human-mode output. */
+export declare function formatTip(message: string): string;
+/** How a command labels a result listing, so its heading stays consistent. */
 export interface ResultListLabels {
     /** Noun phrase after the count, e.g. "cached research"; the "entry/entries" plural is appended. */
     noun: string;
     /** Ordering word shown when truncated: "first" (recency order) or "top" (ranked order). */
     order: 'first' | 'top';
-    /** The command's --limit ceiling, surfaced in the truncation hint. */
-    maxLimit: number;
 }
 /** Heading for a result listing; notes truncation inline when more matched than are shown. */
 export declare function resultListHeading(total: number, shown: number, labels: ResultListLabels): string;
-/**
- * One-line truncation notice for stderr, or null when nothing was cut. Available for human-mode
- * tips; `list --json` surfaces truncation via the envelope `truncation` field instead (#91).
- */
-export declare function truncationNotice(total: number, shown: number, labels: ResultListLabels): string | null;
 /** Max edit distance for a plausible typo; scales with input length. */
 export declare function maxFuzzyDistance(input: string): number;
 /**

package/dist/lib/text.js

@@ -1,5 +1,22 @@
 /** Display label when an artifact has no topic — not a filterable topic value. */
 export const NO_TOPIC_LABEL = '(no topic)';
+// Unicode "Control" category (C0 + C1) covers ANSI/terminal escape sequences: the ESC control
+// character that starts them is a member, so stripping this category is what keeps injected
+// control bytes from reaching a real terminal. Exported so `prompt-injection.ts`'s
+// multi-line-content variant (which preserves tab/newline/CR) shares this one definition.
+export const CONTROL_CHAR_PATTERN = /\p{Cc}/gu;
+/**
+ * Strip ANSI escape codes and other control characters from a cached metadata string before it
+ * reaches a human-readable terminal line. Fields like `topic` and section headings can originate
+ * from fetched web content or agent-supplied notes — both untrusted per the repo's trust-boundary
+ * rules — so a value containing raw escape bytes must never be echoed as-is to a TTY. Newlines and
+ * tabs collapse to a single space rather than being stripped outright, so injected content can't
+ * fake extra output lines while still being removed. JSON output is unaffected: `JSON.stringify`
+ * already escapes control characters, so this only needs to run on the human-readable path.
+ */
+export function sanitizeForTerminal(value) {
+    return value.replace(/[\t\n\r]/g, ' ').replace(CONTROL_CHAR_PATTERN, '');
+}
 /**
  * Pick the singular or plural noun for a count so human-readable output stays grammatical
  * ("1 entry" / "2 entries"). English has irregular plurals, so the plural is passed explicitly
@@ -8,6 +25,10 @@ export const NO_TOPIC_LABEL = '(no topic)';
 export function pluralize(count, singular, plural) {
     return count === 1 ? singular : plural;
 }
+/** Shared "Tip: " prefix for contextual next-step suggestions in human-mode output. */
+export function formatTip(message) {
+    return `Tip: ${message}`;
+}
 /** Heading for a result listing; notes truncation inline when more matched than are shown. */
 export function resultListHeading(total, shown, labels) {
     const noun = `${labels.noun} ${pluralize(total, 'entry', 'entries')}`;
@@ -15,15 +36,6 @@ export function resultListHeading(total, shown, labels) {
         ? `Found ${total} ${noun} (showing ${labels.order} ${shown}; raise --limit to see more):`
         : `Found ${total} ${noun}:`;
 }
-/**
- * One-line truncation notice for stderr, or null when nothing was cut. Available for human-mode
- * tips; `list --json` surfaces truncation via the envelope `truncation` field instead (#91).
- */
-export function truncationNotice(total, shown, labels) {
-    if (total <= shown)
-        return null;
-    return `${total} entries matched; returning the ${labels.order} ${shown}. Raise --limit (max ${labels.maxLimit}) to see more.`;
-}
 /** Max edit distance for a plausible typo; scales with input length. */
 export function maxFuzzyDistance(input) {
     if (input.length <= 3)