@sweny-ai/core 0.1.185 → 0.1.186

package/dist/cli/runs.js

@@ -1,12 +1,15 @@
 /**
  * `sweny runs` and `sweny runs diff`: read-only views over `.sweny/runs/`.
- * Metadata only. Color only when `color` is true (TTY).
+ * `runs` lists metadata. `runs diff` compares the metadata of two runs and,
+ * first, what changed in their answers (run-answers.ts). Color only when
+ * `color` is true (TTY and no NO_COLOR); the glyph set follows `unicode`.
+ * The diff always ends on one plain line with the answer counts.
  */
 import { findRun, listRuns } from "./run-history.js";
+import { compareAnswers, readRunAnswers, } from "./run-answers.js";
 import { formatCost, formatReceiptDuration, formatTokenCount } from "./run-output.js";
 import { createPaint } from "./style.js";
-import { colorEnabled } from "./terminal.js";
-import { GLYPHS } from "../theme.js";
+import { colorEnabled, glyphsFor, sanitizeTerminal, supportsUnicode } from "./terminal.js";
 // ── Small formatters ────────────────────────────────────────────
 export function formatAge(startedAt, nowMs = Date.now()) {
     const s = Math.max(0, Math.round((nowMs - Date.parse(startedAt)) / 1000));
@@ -20,8 +23,14 @@ export function formatAge(startedAt, nowMs = Date.now()) {
         return `${h}h ago`;
     return `${Math.floor(h / 24)}d ago`;
 }
-const G = GLYPHS.unicode;
-const ICON = { success: G.success, failed: G.failure, crashed: G.failure, skipped: G.skipped };
+/** Own keys only: a status of `constructor` from a forged record must not find Object.prototype. */
+const icon = (icons, status) => Object.hasOwn(icons, status) ? icons[status] : "?";
+const iconsFor = (g) => ({
+    success: g.success,
+    failed: g.failure,
+    crashed: g.failure,
+    skipped: g.skipped,
+});
 /** Status text in its role color: success, error, or muted for skipped. */
 function paint(text, status, color) {
     if (!color)
@@ -38,8 +47,49 @@ const costText = (n) => (n === null ? "-" : formatCost(n));
 function pad(s, w, right = false) {
     return right ? s.padStart(w) : s.padEnd(w);
 }
+// ── History records are untrusted ───────────────────────────────
+const finite = (v) => (typeof v === "number" && Number.isFinite(v) ? v : 0);
+const finiteOrNull = (v) => (typeof v === "number" && Number.isFinite(v) ? v : null);
+/**
+ * A copy of a history record that is safe to print. `.sweny/runs/` is writable by an agent, so every
+ * string read from a record goes through {@link sanitizeTerminal} (control sequences stripped, length
+ * capped) and every number is coerced to a finite number. Only for display: matching and `--json`
+ * use the record as read.
+ */
+export function printableRun(r) {
+    const t = (v, max = 64) => sanitizeTerminal(v, max);
+    return {
+        ...r,
+        run_id: t(r.run_id),
+        workflow_id: t(r.workflow_id),
+        workflow_hash: t(r.workflow_hash),
+        started_at: t(r.started_at),
+        status: t(r.status, 16),
+        duration_ms: finite(r.duration_ms),
+        nodes: r.nodes.map((n) => ({
+            id: t(n.id),
+            status: t(n.status, 16),
+            duration_ms: finite(n.duration_ms),
+            tool_calls: finite(n.tool_calls),
+            tokens: finiteOrNull(n.tokens),
+            cost_usd: finiteOrNull(n.cost_usd),
+            retries: finite(n.retries),
+        })),
+        routes: r.routes.map((e) => ({ from: t(e.from), to: t(e.to) })),
+        totals: {
+            nodes_total: finite(r.totals.nodes_total),
+            nodes_ok: finite(r.totals.nodes_ok),
+            nodes_skipped: finite(r.totals.nodes_skipped),
+            tool_calls: finite(r.totals.tool_calls),
+            tokens: finiteOrNull(r.totals.tokens),
+            cost_usd: finiteOrNull(r.totals.cost_usd),
+        },
+    };
+}
 // ── sweny runs ──────────────────────────────────────────────────
-export function formatRunsTable(runs, color, nowMs = Date.now()) {
+export function formatRunsTable(records, color, nowMs = Date.now(), unicode = true) {
+    const ICON = iconsFor(glyphsFor(unicode));
+    const runs = records.map(printableRun);
     if (runs.length === 0)
         return "  No runs recorded yet. Run `sweny workflow run <file>` to start a history.\n";
     const rows = runs.map((r) => ({
@@ -47,7 +97,7 @@ export function formatRunsTable(runs, color, nowMs = Date.now()) {
         cells: [
             r.run_id,
             r.workflow_id,
-            `${ICON[r.status] ?? "?"} ${r.status}`,
+            `${icon(ICON, r.status)} ${r.status}`,
             formatReceiptDuration(r.duration_ms),
             tokensText(r.totals?.tokens ?? null),
             costText(r.totals?.cost_usd ?? null),
@@ -82,41 +132,180 @@ const deltaTokens = (a, b) => `${sign(b - a)}${formatTokenCount(Math.abs(b - a))
 const deltaCost = (a, b) => `${sign(b - a)}${formatCost(Math.abs(b - a))}`;
 const deltaCount = (a, b) => `${sign(b - a)}${Math.abs(b - a)}`;
 /** `label a → b (+delta)` for a numeric metric; null when unchanged. */
-function metric(label, a, b, show, delta) {
+function metric(label, a, b, show, delta, arrow = "→") {
     if (a === b)
         return null;
     if (a === null || b === null)
-        return `${label} ${a === null ? "-" : show(a)} → ${b === null ? "-" : show(b)}`;
-    return `${label} ${show(a)} → ${show(b)} (${delta(a, b)})`;
+        return `${label} ${a === null ? "-" : show(a)} ${arrow} ${b === null ? "-" : show(b)}`;
+    return `${label} ${show(a)} ${arrow} ${show(b)} (${delta(a, b)})`;
 }
-function nodeChanges(a, b) {
+function nodeChanges(a, b, arrow) {
     return [
-        metric("duration", a.duration_ms, b.duration_ms, fmtDur, deltaDuration),
-        metric("tokens", a.tokens, b.tokens, formatTokenCount, deltaTokens),
-        metric("cost", a.cost_usd, b.cost_usd, formatCost, deltaCost),
-        metric("tools", a.tool_calls, b.tool_calls, String, deltaCount),
-        metric("retries", a.retries, b.retries, String, deltaCount),
+        metric("duration", a.duration_ms, b.duration_ms, fmtDur, deltaDuration, arrow),
+        metric("tokens", a.tokens, b.tokens, formatTokenCount, deltaTokens, arrow),
+        metric("cost", a.cost_usd, b.cost_usd, formatCost, deltaCost, arrow),
+        metric("tools", a.tool_calls, b.tool_calls, String, deltaCount, arrow),
+        metric("retries", a.retries, b.retries, String, deltaCount, arrow),
     ].filter((x) => x !== null);
 }
-const routeKey = (r) => `${r.from} → ${r.to}`;
-export function formatRunDiff(a, b, color) {
+const routeKey = (r) => `${r.from}\u0000${r.to}`;
+// ── Answers section ─────────────────────────────────────────────
+/** Items listed per kind (added, resolved, changed) in one list before "... and N more". The JSON keeps all. */
+const MAX_ITEMS_SHOWN = 10;
+const MAX_FIELDS_SHOWN = 3;
+const VALUE_MAX = 56;
+/** One printable line (an answer is untrusted text): see {@link sanitizeTerminal}. */
+const oneLine = (s) => sanitizeTerminal(s, 10_000);
+function clip(s, max, g) {
+    return s.length > max ? s.slice(0, max - 1) + g.ellipsis : s;
+}
+function showValue(v, g) {
+    if (v === undefined)
+        return "(none)";
+    const text = typeof v === "string" ? v : typeof v === "number" || typeof v === "boolean" ? String(v) : JSON.stringify(v);
+    return clip(oneLine(text), VALUE_MAX, g);
+}
+/** Lines in `b` not in `a` (added) and in `a` not in `b` (removed), as multisets. */
+function lineDelta(a, b) {
+    const left = new Map();
+    for (const l of a.split("\n"))
+        left.set(l, (left.get(l) ?? 0) + 1);
+    let added = 0;
+    for (const l of b.split("\n")) {
+        const n = left.get(l) ?? 0;
+        if (n > 0)
+            left.set(l, n - 1);
+        else
+            added++;
+    }
+    let removed = 0;
+    for (const n of left.values())
+        removed += n;
+    return { added, removed };
+}
+/** `before -> after`, or `+X -Y lines` when either side is a long or multi-line string. */
+function valueChange(before, after, g) {
+    // Stored text is cut at ANSWER_STRING_MAX; the change is past the cut (found by digest).
+    if (typeof before === "string" && before === after)
+        return "changed past the stored excerpt";
+    const long = (v) => typeof v === "string" && (v.includes("\n") || v.length > VALUE_MAX);
+    if (typeof before === "string" && typeof after === "string" && (long(before) || long(after))) {
+        const d = lineDelta(before, after);
+        return `+${d.added} -${d.removed} lines`;
+    }
+    return `${showValue(before, g)} ${g.arrow} ${showValue(after, g)}`;
+}
+const isChangedEntry = (e) => e.kind === "collection" ? e.added.length + e.resolved.length + e.changed.length > 0 : e.status !== "unchanged";
+function countsHead(e, g) {
+    return [
+        e.added.length ? `${e.added.length} added` : "",
+        e.resolved.length ? `${e.resolved.length} resolved` : "",
+        e.changed.length ? `${e.changed.length} changed` : "",
+        e.unchanged ? `${e.unchanged} unchanged` : "",
+    ]
+        .filter(Boolean)
+        .join(` ${g.sep} `);
+}
+/**
+ * The answers block. Marker colors keep the palette's meanings: `+` a new item
+ * is `warning` (look at this), `-` a resolved one is `success`, `~` a changed
+ * one is `info`; counts and unchanged nodes are `muted`.
+ */
+function formatAnswersSection(cmp, color, g) {
+    const p = createPaint(color);
+    const out = ["  answers"];
+    const items = (marker, paintMarker, list, word) => {
+        for (const it of list.slice(0, MAX_ITEMS_SHOWN)) {
+            out.push(`        ${paintMarker(marker)} ${clip(oneLine(it.label), 72, g)}`);
+        }
+        if (list.length > MAX_ITEMS_SHOWN) {
+            out.push(p.muted(`        ${g.ellipsis} and ${list.length - MAX_ITEMS_SHOWN} more ${word}`));
+        }
+    };
+    const fields = (list) => {
+        if (list.length === 0)
+            return;
+        const w = Math.max(...list.map((f) => f.field.length));
+        for (const f of list.slice(0, MAX_FIELDS_SHOWN)) {
+            out.push(`            ${pad(f.field, w)}  ${valueChange(f.before, f.after, g)}`);
+        }
+        if (list.length > MAX_FIELDS_SHOWN)
+            out.push(p.muted(`            ${g.ellipsis} and ${list.length - MAX_FIELDS_SHOWN} more fields`));
+    };
+    const nodes = [...new Set(cmp.entries.map((e) => e.node))];
+    for (const node of nodes) {
+        const changed = cmp.entries.filter((e) => e.node === node && isChangedEntry(e));
+        if (changed.length === 0) {
+            out.push(`    ${node}  ${p.muted("unchanged")}`);
+            continue;
+        }
+        out.push(`    ${node}`);
+        const w = Math.max(...changed.map((e) => e.field.length));
+        for (const e of changed) {
+            if (e.kind === "collection") {
+                out.push(`      ${pad(e.field, w)}  ${p.muted(countsHead(e, g))}`);
+                items("+", p.warning, e.added, "added");
+                items("-", p.success, e.resolved, "resolved");
+                for (const c of e.changed.slice(0, MAX_ITEMS_SHOWN)) {
+                    out.push(`        ${p.info("~")} ${clip(oneLine(c.label), 72, g)}`);
+                    fields(c.fields);
+                }
+                if (e.changed.length > MAX_ITEMS_SHOWN) {
+                    out.push(p.muted(`        ${g.ellipsis} and ${e.changed.length - MAX_ITEMS_SHOWN} more changed`));
+                }
+            }
+            else if (e.status === "added") {
+                out.push(`      ${pad(e.field, w)}  ${p.warning("added")} ${showValue(e.after, g)}`);
+            }
+            else if (e.status === "resolved") {
+                out.push(`      ${pad(e.field, w)}  ${p.success("resolved")} ${p.muted(`(was ${showValue(e.before, g)})`)}`);
+            }
+            else {
+                out.push(`      ${pad(e.field, w)}  ${valueChange(e.before, e.after, g)}`);
+            }
+        }
+    }
+    for (const n of cmp.not_compared) {
+        out.push(`    ${n.node}  ${p.muted(`not compared (answer in ${n.only_in} only)`)}`);
+    }
+    if (nodes.length === 0 && cmp.not_compared.length === 0)
+        out.push(p.muted("    no declared outputs to compare"));
+    return out;
+}
+const countsLine = (c) => `${c.added} added, ${c.resolved} resolved, ${c.changed} changed, ${c.unchanged} unchanged`;
+/** The last line of the diff: plain text, no color, no glyphs, so a log or a grep always has the answer. */
+function answersFinalLine(cmp, a, b) {
+    if (cmp.available)
+        return `  answers: ${countsLine(cmp.counts)}`;
+    if (cmp.reason === "different_workflows")
+        return "  answers: not compared (different workflows)";
+    const ids = cmp.missing.map((m) => (m === "a" ? a.run_id : b.run_id)).join(" and ");
+    return `  answers: not recorded for ${ids} (runs made with --no-history, or by an older sweny, have none)`;
+}
+export function formatRunDiff(rawA, rawB, color, opts = {}) {
+    const a = printableRun(rawA);
+    const b = printableRun(rawB);
+    const g = glyphsFor(opts.unicode ?? true);
+    const ICON = iconsFor(g);
     const dim = createPaint(color).muted;
     const out = [];
-    const hdr = (tag, r) => `  ${tag}  ${r.run_id}  ${r.workflow_id}  ${paint(`${ICON[r.status] ?? "?"} ${r.status}`, r.status, color)}  ${formatReceiptDuration(r.duration_ms)}`;
+    const hdr = (tag, r) => `  ${tag}  ${r.run_id}  ${r.workflow_id}  ${paint(`${icon(ICON, r.status)} ${r.status}`, r.status, color)}  ${formatReceiptDuration(r.duration_ms)}`;
     out.push(hdr("a", a), hdr("b", b), "");
+    if (opts.answers?.available)
+        out.push(...formatAnswersSection(opts.answers, color, g), "");
     const short = (h) => h.slice(0, 7);
     out.push(a.workflow_hash === b.workflow_hash
         ? `  workflow   unchanged (${short(a.workflow_hash)})`
-        : `  workflow   changed ${short(a.workflow_hash)} → ${short(b.workflow_hash)}`);
+        : `  workflow   changed ${short(a.workflow_hash)} ${g.arrow} ${short(b.workflow_hash)}`);
     if (a.workflow_id !== b.workflow_id)
-        out.push(`  id         ${a.workflow_id} → ${b.workflow_id}`);
+        out.push(`  id         ${a.workflow_id} ${g.arrow} ${b.workflow_id}`);
     out.push(a.status === b.status
-        ? `  status     ${ICON[b.status]} ${b.status} (same)`
-        : `  status     ${ICON[a.status]} ${a.status} → ${paint(`${ICON[b.status]} ${b.status}`, b.status, color)}`);
+        ? `  status     ${icon(ICON, b.status)} ${b.status} (same)`
+        : `  status     ${icon(ICON, a.status)} ${a.status} ${g.arrow} ${paint(`${icon(ICON, b.status)} ${b.status}`, b.status, color)}`);
     const tot = [
-        metric("duration  ", a.duration_ms, b.duration_ms, formatReceiptDuration, deltaDuration),
-        metric("tokens    ", a.totals.tokens, b.totals.tokens, formatTokenCount, deltaTokens),
-        metric("cost      ", a.totals.cost_usd, b.totals.cost_usd, formatCost, deltaCost),
+        metric("duration  ", a.duration_ms, b.duration_ms, formatReceiptDuration, deltaDuration, g.arrow),
+        metric("tokens    ", a.totals.tokens, b.totals.tokens, formatTokenCount, deltaTokens, g.arrow),
+        metric("cost      ", a.totals.cost_usd, b.totals.cost_usd, formatCost, deltaCost, g.arrow),
     ];
     for (const t of tot)
         if (t)
@@ -130,18 +319,21 @@ export function formatRunDiff(a, b, color) {
         const na = aNodes.get(id);
         const nb = bNodes.get(id);
         if (na && !nb) {
-            out.push(`    ${pad(id, w)}  ${dim("removed")} (was ${ICON[na.status]} ${na.status})`);
+            out.push(`    ${pad(id, w)}  ${dim("removed")} (was ${icon(ICON, na.status)} ${na.status})`);
         }
         else if (!na && nb) {
-            out.push(`    ${pad(id, w)}  ${paint(`added ${ICON[nb.status]} ${nb.status}`, nb.status, color)}`);
+            out.push(`    ${pad(id, w)}  ${paint(`added ${icon(ICON, nb.status)} ${nb.status}`, nb.status, color)}`);
         }
         else if (na && nb) {
-            const st = na.status === nb.status ? ICON[nb.status] : `${ICON[na.status]} → ${paint(ICON[nb.status], nb.status, color)}`;
-            const ch = nodeChanges(na, nb);
+            const st = na.status === nb.status
+                ? icon(ICON, nb.status)
+                : `${icon(ICON, na.status)} ${g.arrow} ${paint(icon(ICON, nb.status), nb.status, color)}`;
+            const ch = nodeChanges(na, nb, g.arrow);
             out.push(`    ${pad(id, w)}  ${st}  ${ch.length ? ch.join("   ") : dim("no change")}`);
         }
     }
     out.push("", "  routes");
+    const show = (key) => key.split("\u0000").join(` ${g.arrow} `);
     const ar = new Set(a.routes.map(routeKey));
     const br = new Set(b.routes.map(routeKey));
     const onlyA = [...ar].filter((r) => !br.has(r));
@@ -149,9 +341,11 @@ export function formatRunDiff(a, b, color) {
     if (onlyA.length === 0 && onlyB.length === 0)
         out.push("    identical");
     for (const r of onlyA)
-        out.push(`    - ${r}  ${dim("(only in a)")}`);
+        out.push(`    - ${show(r)}  ${dim("(only in a)")}`);
     for (const r of onlyB)
-        out.push(`    + ${r}  ${dim("(only in b)")}`);
+        out.push(`    + ${show(r)}  ${dim("(only in b)")}`);
+    if (opts.answers)
+        out.push("", answersFinalLine(opts.answers, a, b));
     return out.join("\n") + "\n";
 }
 /** Pick two runs: explicit refs, or the newest two runs of one workflow (--workflow, else the newest workflow with two or more runs). a = older, b = newer. */
@@ -162,9 +356,9 @@ export function pickRunsForDiff(runs, refs, workflowId) {
         const a = findRun(runs, refs[0]);
         const b = findRun(runs, refs[1]);
         if (!a)
-            return { error: `No run matches "${refs[0]}". Run \`sweny runs\` to list ids.` };
+            return { error: `No run matches "${sanitizeTerminal(refs[0], 64)}". Run \`sweny runs\` to list ids.` };
         if (!b)
-            return { error: `No run matches "${refs[1]}". Run \`sweny runs\` to list ids.` };
+            return { error: `No run matches "${sanitizeTerminal(refs[1], 64)}". Run \`sweny runs\` to list ids.` };
         return { a, b };
     }
     // No --workflow: the newest workflow that has at least two runs to compare.
@@ -174,10 +368,37 @@ export function pickRunsForDiff(runs, refs, workflowId) {
     const wf = workflowId ?? runs.find((r) => (counts.get(r.workflow_id) ?? 0) >= 2)?.workflow_id ?? runs[0]?.workflow_id;
     const same = wf ? runs.filter((r) => r.workflow_id === wf) : [];
     if (same.length < 2) {
-        return { error: wf ? `Need two runs of "${wf}" to diff; found ${same.length}.` : "No runs recorded yet." };
+        return {
+            error: wf
+                ? `Need two runs of "${sanitizeTerminal(wf, 64)}" to diff; found ${same.length}. Run it again, then \`sweny runs diff\`.`
+                : "No runs recorded yet. Run `sweny workflow run <file>` twice, then `sweny runs diff`.",
+        };
     }
     return { a: same[1], b: same[0] };
 }
+/**
+ * Body of `sweny runs diff`. Returns the exit code (0 diffed, 1 nothing to diff).
+ *
+ * `--json` prints `{ schema_version: 1, a: RunRecord, b: RunRecord, answers }` and never ANSI.
+ * `answers` is `{ available: true, counts, entries, not_compared }` or
+ * `{ available: false, reason: "different_workflows" | "missing_answers", missing? }`.
+ */
+export function runRunsDiff(refs, opts, io) {
+    const env = io.env ?? process.env;
+    const picked = pickRunsForDiff(listRuns(io.cwd), refs, opts.workflow);
+    if ("error" in picked) {
+        io.stderr.write(createPaint(colorEnabled(io.stderr, env)).error(`  ${picked.error}`) + "\n");
+        return 1;
+    }
+    const { a, b } = picked;
+    const answers = compareAnswers(readRunAnswers(a.run_id, io.cwd), readRunAnswers(b.run_id, io.cwd));
+    if (opts.json) {
+        io.stdout.write(JSON.stringify({ schema_version: 1, a, b, answers }, null, 2) + "\n");
+        return 0;
+    }
+    io.stdout.write("\n" + formatRunDiff(a, b, colorEnabled(io.stdout, env), { answers, unicode: supportsUnicode(env) }) + "\n");
+    return 0;
+}
 // ── Command wiring ──────────────────────────────────────────────
 export function registerRunsCommand(program) {
     const runsCmd = program
@@ -201,22 +422,18 @@ export function registerRunsCommand(program) {
             process.stdout.write(JSON.stringify(runs, null, 2) + "\n");
             return;
         }
-        process.stdout.write("\n" + formatRunsTable(runs, colorEnabled(process.stdout)) + "\n");
+        process.stdout.write("\n" + formatRunsTable(runs, colorEnabled(process.stdout), Date.now(), supportsUnicode()) + "\n");
     });
     runsCmd
         .command("diff [a] [b]")
-        .description("Compare two runs (default: the last two runs of the same workflow)")
+        .description("Compare two runs: what changed in the answers, then how they ran (default: the last two of a workflow)")
         .option("--workflow <id>", "Workflow to pick the default pair from")
+        .option("--json", "Output { schema_version, a, b, answers } as JSON")
         .action((a, b, opts) => {
         const refs = [a, b].filter((x) => x !== undefined);
-        const runs = listRuns();
-        const picked = pickRunsForDiff(runs, refs, opts.workflow);
-        if ("error" in picked) {
-            console.error(createPaint(colorEnabled(process.stderr)).error(`  ${picked.error}`));
-            process.exitCode = 1;
-            return;
-        }
-        process.stdout.write("\n" + formatRunDiff(picked.a, picked.b, colorEnabled(process.stdout)) + "\n");
+        const code = runRunsDiff(refs, opts, { stdout: process.stdout, stderr: process.stderr });
+        if (code !== 0)
+            process.exitCode = code;
     });
     return runsCmd;
 }

package/dist/cli/terminal.d.ts

@@ -42,6 +42,15 @@ export declare function ticketBoxFor(unicode: boolean): TicketBox;
 export declare function spinnerFramesFor(unicode: boolean): readonly string[];
 /** The glyphs for the current process. */
 export declare function glyphs(env?: Env): GlyphSet;
+/**
+ * Text that came from a file an agent can write (run history, say), made safe to print: terminal
+ * control sequences are removed whole (CSI such as `ESC[2J`, OSC such as the `ESC]8;;url` hyperlink
+ * and title sequences, DCS/PM/APC strings, lone ESC pairs, their 8-bit C1 forms), then any other
+ * C0/C1 control character, bidi override and line separator is dropped or becomes a space; runs of
+ * whitespace collapse to one space. Printable Unicode is kept. `max` caps the length (default 200,
+ * `...` marks a cut).
+ */
+export declare function sanitizeTerminal(text: unknown, max?: number): string;
 /** Replace single-column Unicode drawing characters with their ASCII stand-ins. */
 export declare function toAsciiDrawing(text: string): string;
 export {};

package/dist/cli/terminal.js

@@ -80,6 +80,28 @@ export function spinnerFramesFor(unicode) {
 export function glyphs(env = process.env) {
     return glyphsFor(supportsUnicode(env));
 }
+/**
+ * Text that came from a file an agent can write (run history, say), made safe to print: terminal
+ * control sequences are removed whole (CSI such as `ESC[2J`, OSC such as the `ESC]8;;url` hyperlink
+ * and title sequences, DCS/PM/APC strings, lone ESC pairs, their 8-bit C1 forms), then any other
+ * C0/C1 control character, bidi override and line separator is dropped or becomes a space; runs of
+ * whitespace collapse to one space. Printable Unicode is kept. `max` caps the length (default 200,
+ * `...` marks a cut).
+ */
+export function sanitizeTerminal(text, max = 200) {
+    const s = String(text ?? "")
+        // OSC (ESC ] / 0x9d) up to BEL or ST; DCS, SOS, PM, APC (ESC P X ^ _ / 0x90 0x98 0x9e 0x9f) up to ST
+        .replace(/(?:\x1b\]|\x9d)[^\x07\x1b\x9c]*(?:\x07|\x1b\\|\x9c)?/g, "")
+        .replace(/(?:\x1b[PX^_]|[\x90\x98\x9e\x9f])[^\x1b\x9c]*(?:\x1b\\|\x9c)?/g, "")
+        // CSI (ESC [ / 0x9b): parameters, intermediates, final byte
+        .replace(/(?:\x1b\[|\x9b)[0-?]*[ -/]*[@-~]?/g, "")
+        // any other ESC pair
+        .replace(/\x1b[ -~]?/g, "")
+        .replace(/[\u2028\u2029\s]+/g, " ")
+        .replace(/[\x00-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g, "")
+        .trim();
+    return s.length > max ? s.slice(0, Math.max(0, max - 3)) + "..." : s;
+}
 function truthy(v) {
     return v !== undefined && v !== "" && v !== "0" && v.toLowerCase() !== "false";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.185",
+  "version": "0.1.186",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"