interference-agent 0.1.0 → 0.2.2

package/src/tui/DiffView.tsx

@@ -1,19 +1,25 @@
 export interface DiffLine {
   type: "same" | "add" | "remove";
   text: string;
+  oldNo?: number; // numero riga nel file vecchio (1-based) — same/remove
+  newNo?: number; // numero riga nel file nuovo (1-based) — same/add
 }
 
 export function computeDiff(oldLines: string[], newLines: string[]): DiffLine[] {
   const result: DiffLine[] = [];
   let oi = 0;
   let ni = 0;
+  // Numeri di riga 1-based: oi/ni sono indici 0-based → +1 al push.
+  const same = (t: string) => result.push({ type: "same", text: t, oldNo: oi + 1, newNo: ni + 1 });
+  const rem = (t: string) => result.push({ type: "remove", text: t, oldNo: oi + 1 });
+  const add = (t: string) => result.push({ type: "add", text: t, newNo: ni + 1 });
 
   while (oi < oldLines.length && ni < newLines.length) {
     const old = oldLines[oi]!;
     const nw = newLines[ni]!;
 
     if (old === nw) {
-      result.push({ type: "same", text: old });
+      same(old);
       oi++;
       ni++;
       continue;
@@ -21,32 +27,32 @@ export function computeDiff(oldLines: string[], newLines: string[]): DiffLine[]
 
     const oldEnd = findEnd(oldLines, newLines, oi, ni);
     if (oldEnd.oi === oi) {
-      result.push({ type: "add", text: nw });
+      add(nw);
       ni++;
       continue;
     }
     if (oldEnd.ni === ni) {
-      result.push({ type: "remove", text: old });
+      rem(old);
       oi++;
       continue;
     }
 
     while (oi < oldEnd.oi) {
-      result.push({ type: "remove", text: oldLines[oi]! });
+      rem(oldLines[oi]!);
       oi++;
     }
     while (ni < oldEnd.ni) {
-      result.push({ type: "add", text: newLines[ni]! });
+      add(newLines[ni]!);
       ni++;
     }
   }
 
   while (oi < oldLines.length) {
-    result.push({ type: "remove", text: oldLines[oi]! });
+    rem(oldLines[oi]!);
     oi++;
   }
   while (ni < newLines.length) {
-    result.push({ type: "add", text: newLines[ni]! });
+    add(newLines[ni]!);
     ni++;
   }
 
@@ -71,17 +77,11 @@ function findEnd(
 
 export function formatDiff(diff: DiffLine[]): string {
   const lines: string[] = [];
+  const no = (n?: number) => String(n ?? "").padStart(4, " ");
   for (const d of diff.slice(0, 80)) {
-    switch (d.type) {
-      case "add":
-        lines.push(`+ ${d.text}`);
-        break;
-      case "remove":
-        lines.push(`- ${d.text}`);
-        break;
-      default:
-        lines.push(`  ${d.text}`);
-    }
+    const num = d.type === "add" ? no(d.newNo) : no(d.oldNo);
+    const mark = d.type === "add" ? "+" : d.type === "remove" ? "-" : " ";
+    lines.push(`${num} ${mark} ${d.text}`);
   }
   if (diff.length > 80) lines.push(`… and ${diff.length - 80} more lines`);
   return lines.join("\n");

package/src/tui/MarkdownText.tsx

@@ -1,5 +1,6 @@
 import { Box, Text } from "ink";
 import type { ReactNode } from "react";
+import { tokenizeLine, normalizeLang } from "./syntax.ts";
 
 // Rendering markdown minimale per il terminale (no dipendenze):
 // - fenced code ``` → blocco dim
@@ -32,14 +33,35 @@ export function MarkdownText({ content }: { content: string }) {
   const lines = content.split("\n");
   const blocks: ReactNode[] = [];
   let inFence = false;
+  let lang = "";
+  let fenceLines = 0;
 
   lines.forEach((line, i) => {
-    if (line.trimStart().startsWith("```")) {
-      inFence = !inFence;
+    const t = line.trimStart();
+    if (t.startsWith("```")) {
+      if (!inFence) {
+        inFence = true;
+        lang = normalizeLang(t.slice(3));
+        fenceLines = 0;
+      } else {
+        inFence = false;
+        lang = "";
+      }
       return; // nascondi i marker di fence
     }
     if (inFence) {
-      blocks.push(<Text key={i} dimColor>  {line}</Text>);
+      if (++fenceLines > 200) return; // cap di sicurezza
+      const toks = tokenizeLine(line, lang);
+      blocks.push(
+        <Text key={i}>
+          {"  "}
+          {toks.map((tk, j) => (
+            <Text key={j} color={tk.color} dimColor={tk.dim}>
+              {tk.text}
+            </Text>
+          ))}
+        </Text>,
+      );
       return;
     }
     const heading = /^(#{1,6})\s+(.*)$/.exec(line);

package/src/tui/ModelPicker.tsx

@@ -1,6 +1,7 @@
 import { useState, type FC } from "react";
 import { Box, Text, useInput } from "ink";
 import { currentModel, setModel, setProvider, PROVIDERS, type ProviderId } from "../config.ts";
+import { SelectRow } from "./SelectRow.tsx";
 
 export const ModelPicker: FC<{ onCancel: () => void }> = ({ onCancel }) => {
   const current = currentModel();
@@ -30,13 +31,13 @@ export const ModelPicker: FC<{ onCancel: () => void }> = ({ onCancel }) => {
     <Box flexDirection="column" borderStyle="round" borderColor="blue" padding={1}>
       <Box marginBottom={1}><Text bold>Select model</Text></Box>
       {flat.map((m, i) => (
-        <Box key={m.id}>
-          <Text color={i === idx ? "cyan" : undefined} bold={i === idx}>
-            {i === idx ? "▸ " : "  "}{m.label}
-          </Text>
-          <Text dimColor> · {m.provider}</Text>
-          {m.id === current && <Text color="cyan"> (active)</Text>}
-        </Box>
+        <SelectRow
+          key={m.id}
+          label={m.label}
+          meta={`· ${m.provider}`}
+          selected={i === idx}
+          current={m.id === current}
+        />
       ))}
       <Box marginTop={1}><Text dimColor>↑↓ j/k navigate · Enter select · Esc cancel</Text></Box>
     </Box>

package/src/tui/Panel.tsx

@@ -1,35 +1,39 @@
 import { Box, Text, useStdout } from "ink";
-import { PANEL, padRight, panelWidth } from "./theme.ts";
+import { BG_PANEL, BG_ELEMENT, padRight, panelWidth } from "./theme.ts";
 
 // Pannello con sfondo REALE: ogni riga è un <Text backgroundColor> riempito di
 // spazi fino alla larghezza, così il colore si vede (il bg dei <Box> in Ink non
 // riempie il padding). Barra laterale opzionale come primo carattere della riga.
+// level: "element" (#1e1e1e, messaggi/selezione) | "panel" (#141414, blocchi/dialog).
 export function Panel({
   content,
   bar,
   barColor,
   bold,
+  level = "element",
 }: {
   content: string;
   bar?: string;
   barColor?: string;
   bold?: boolean;
+  level?: "panel" | "element";
 }) {
   const { stdout } = useStdout();
   const w = panelWidth(stdout?.columns);
+  const bg = level === "panel" ? BG_PANEL : BG_ELEMENT;
   const prefix = bar ? `${bar} ` : "";
   const lines = content.split("\n");
 
   return (
     <Box flexDirection="column" marginBottom={1}>
       {lines.map((ln, i) => (
-        <Text key={i} backgroundColor={PANEL} color="white" bold={bold}>
+        <Text key={i} backgroundColor={bg} color="white" bold={bold}>
           {bar && i === 0 ? (
-            <Text backgroundColor={PANEL} color={barColor} bold>
+            <Text backgroundColor={bg} color={barColor} bold>
               {prefix}
             </Text>
           ) : (
-            <Text backgroundColor={PANEL}>{bar ? "  " : ""}</Text>
+            <Text backgroundColor={bg}>{bar ? "  " : ""}</Text>
           )}
           {padRight(ln, w - prefix.length)}
         </Text>

package/src/tui/SelectRow.tsx

@@ -0,0 +1,40 @@
+import { Text, useStdout } from "ink";
+import { BG_ELEMENT, padRight, panelWidth } from "./theme.ts";
+
+// Riga di selezione stile opencode (it. 24): selezione = sfondo a riga piena,
+// `●` per il valore corrente (vs `  `). Niente pointer `▸`.
+export function SelectRow({
+  label,
+  meta,
+  selected,
+  current,
+  color = "white",
+}: {
+  label: string;
+  meta?: string;
+  selected: boolean;
+  current?: boolean;
+  color?: string;
+}) {
+  const { stdout } = useStdout();
+  const w = Math.min(panelWidth(stdout?.columns), 72);
+  const marker = current ? "● " : "  ";
+
+  if (selected) {
+    const text = `${marker}${label}${meta ? "  " + meta : ""}`;
+    return (
+      <Text backgroundColor={BG_ELEMENT} color="white" bold>
+        {padRight(text, w)}
+      </Text>
+    );
+  }
+  return (
+    <Text>
+      <Text color={current ? color : undefined} bold={current}>
+        {marker}
+        {label}
+      </Text>
+      {meta ? <Text dimColor>{"  " + meta}</Text> : null}
+    </Text>
+  );
+}

package/src/tui/SessionList.tsx

@@ -1,6 +1,7 @@
 import { useState, useEffect, useCallback, type FC } from "react";
 import { Box, Text, useInput } from "ink";
 import { listSessions, loadSession, type SessionMeta } from "../session/store.ts";
+import { SelectRow } from "./SelectRow.tsx";
 
 interface Props {
   onSelect: (sessionId: string) => void;
@@ -56,13 +57,12 @@ export const SessionList: FC<Props> = ({ onSelect, onCancel }) => {
         <Text bold>Sessions ({sessions.length})</Text>
       </Box>
       {sessions.slice(0, PAGE_SIZE).map((s, i) => (
-        <Box key={s.id}>
-          <Text color={i === idx ? "cyan" : undefined} bold={i === idx}>
-            {i === idx ? "▸" : " "}
-          </Text>
-          <Text dimColor>{s.id.slice(0, 12)}</Text>
-          <Text> {s.mode} · {s.turnCount}t · {s.updatedAt.slice(0, 10)}</Text>
-        </Box>
+        <SelectRow
+          key={s.id}
+          label={s.id.slice(0, 12)}
+          meta={`${s.mode} · ${s.turnCount}t · ${s.updatedAt.slice(0, 10)}`}
+          selected={i === idx}
+        />
       ))}
       <Box marginTop={1}>
         <Text dimColor>↑↓ j/k navigate · Enter select · Esc/q cancel</Text>

package/src/tui/Spinner.tsx

@@ -0,0 +1,43 @@
+import { useState, useEffect } from "react";
+import { Text } from "ink";
+
+// Spinner d'interferenza (it. 26), eco del mark animato del brand
+// (logo/interference-mark-animated.svg): due sorgenti `◉` i cui fronti d'onda `‹ ›`
+// si espandono verso il centro e interferiscono in `✕`, poi svaniscono e ripartono.
+// Tutti i frame larghi 7 → niente jitter.
+const FRAMES = [
+  "◉     ◉",
+  "◉‹   ›◉",
+  "◉‹‹ ››◉",
+  "◉‹‹✕››◉",
+  "◉‹ ✕ ›◉",
+  "◉  ✕  ◉",
+  "◉  ·  ◉",
+];
+
+// Variante compatta (3 col) per le righe inline dei tool.
+const FRAMES_INLINE = ["‹✕›", "·✕·", " ✕ ", "‹ ›"];
+
+function useFrame(frames: string[], ms: number): string {
+  const [i, setI] = useState(0);
+  useEffect(() => {
+    const t = setInterval(() => setI((x) => (x + 1) % frames.length), ms);
+    return () => clearInterval(t);
+  }, [frames, ms]);
+  return frames[i]!;
+}
+
+export function Spinner({ label }: { label?: string }) {
+  const frame = useFrame(FRAMES, 110);
+  return (
+    <Text>
+      <Text color="white">{frame}</Text>
+      {label ? <Text dimColor>{" " + label}</Text> : null}
+    </Text>
+  );
+}
+
+export function SpinnerInline() {
+  const frame = useFrame(FRAMES_INLINE, 130);
+  return <Text dimColor>{frame}</Text>;
+}

package/src/tui/ThinkingPicker.tsx

@@ -1,6 +1,7 @@
 import { useState, type FC } from "react";
 import { Box, Text, useInput } from "ink";
 import { currentProvider, currentThinking, type ThinkingLevel } from "../config.ts";
+import { SelectRow } from "./SelectRow.tsx";
 
 interface Props {
   onSelect: (level: ThinkingLevel) => void;
@@ -40,14 +41,13 @@ export const ThinkingPicker: FC<Props> = ({ onSelect, onCancel }) => {
         <Text bold>Thinking level · {provider.label}</Text>
       </Box>
       {levels.map((l, i) => (
-        <Box key={l}>
-          <Text color={i === idx ? "magenta" : undefined} bold={i === idx}>
-            {i === idx ? "▸ " : "  "}
-            {l}
-          </Text>
-          {l === current && <Text dimColor> (current)</Text>}
-          {HINT[l] && <Text dimColor> — {HINT[l]}</Text>}
-        </Box>
+        <SelectRow
+          key={l}
+          label={l}
+          meta={HINT[l]}
+          selected={i === idx}
+          current={l === current}
+        />
       ))}
       <Box marginTop={1}>
         <Text dimColor>↑↓ j/k navigate · Enter select · Esc cancel</Text>

package/src/tui/ToolStep.tsx

@@ -1,6 +1,35 @@
-import { Box, Text } from "ink";
-import { Spinner } from "@inkjs/ui";
+import type { ReactNode } from "react";
+import { Box, Text, useStdout } from "ink";
+import { SpinnerInline } from "./Spinner.tsx";
 import type { DiffLine } from "./DiffView.tsx";
+import { BG_PANEL, DIFF_ADD_BG, DIFF_REM_BG, panelWidth } from "./theme.ts";
+
+const fill = (w: number, used: number) => " ".repeat(Math.max(0, w - used));
+
+// Riga di diff: numero riga + marker + testo, su sfondo verde/rosso attenuato (it. 20).
+function DiffLineRow({ d, w }: { d: DiffLine; w: number }) {
+  const bg = d.type === "add" ? DIFF_ADD_BG : d.type === "remove" ? DIFF_REM_BG : BG_PANEL;
+  const fg = d.type === "add" ? "green" : d.type === "remove" ? "red" : undefined;
+  const num = String((d.type === "add" ? d.newNo : d.oldNo) ?? "").padStart(4, " ");
+  const mark = d.type === "add" ? "+ " : d.type === "remove" ? "- " : "  ";
+  const text = d.text.slice(0, Math.max(0, w - 9));
+  const used = 2 + 4 + 1 + 2 + text.length; // barra + numero + spazio + marker + testo
+  return (
+    <Text backgroundColor={bg}>
+      <Text color="gray" bold backgroundColor={bg}>
+        {"▌ "}
+      </Text>
+      <Text dimColor backgroundColor={bg}>
+        {num}{" "}
+      </Text>
+      <Text color={fg} dimColor={d.type === "same"} backgroundColor={bg}>
+        {mark}
+        {text}
+      </Text>
+      <Text backgroundColor={bg}>{fill(w, used)}</Text>
+    </Text>
+  );
+}
 
 // Vista di un tool step (call → result). Allineata a ToolEntry in App.tsx.
 export interface ToolView {
@@ -27,6 +56,21 @@ const ICON: Record<string, string> = {
   task: "│",
 };
 
+// Testo descrittivo durante l'esecuzione (it. 21, stile opencode `~ <verbo>…`).
+const PENDING: Record<string, string> = {
+  bash: "Running command…",
+  read: "Reading file…",
+  ls: "Listing…",
+  glob: "Finding files…",
+  grep: "Searching content…",
+  webfetch: "Fetching…",
+  websearch: "Searching web…",
+  todowrite: "Updating todos…",
+  question: "Asking…",
+  task: "Delegating…",
+};
+const pendingText = (name: string) => PENDING[name] ?? "Working…";
+
 // Tool con output complesso → blocco con bordo sinistro. Gli altri → riga inline.
 const BLOCK = new Set(["bash", "write", "edit"]);
 
@@ -94,26 +138,59 @@ function InlineTool({
   desc: string;
   pending: boolean;
 }) {
-  const iconColor = tool.isError ? "red" : "cyan";
+  const iconColor = tool.isError ? "red" : "white";
   return (
     <Box flexDirection="column" paddingLeft={3}>
       <Box>
-        <Text color={iconColor}>{icon} </Text>
-        <Text color={tool.isError ? "red" : undefined} dimColor={!tool.isError && !pending}>
-          {tool.toolName} {desc}
-        </Text>
-        {pending && <Spinner label="" />}
+        {/* icona a larghezza fissa (2 col) → allineamento tra tool diversi */}
+        <Box width={2}>
+          <Text color={iconColor}>{icon}</Text>
+        </Box>
+        {pending ? (
+          <>
+            <Text dimColor>~ {pendingText(tool.toolName)} </Text>
+            <SpinnerInline />
+          </>
+        ) : (
+          <Text color={tool.isError ? "red" : undefined} dimColor={!tool.isError}>
+            {tool.toolName} {desc}
+          </Text>
+        )}
       </Box>
       {!pending && tool.output && (
-        <Text dimColor color={tool.isError ? "red" : undefined}>
-          {"  "}
-          {oneLine(tool.output)}
-        </Text>
+        <Box paddingLeft={2}>
+          <Text dimColor color={tool.isError ? "red" : undefined}>
+            {oneLine(tool.output)}
+          </Text>
+        </Box>
       )}
     </Box>
   );
 }
 
+// Riga del pannello: barra "▌ " (2 col) + contenuto + riempimento di sfondo a larghezza.
+function PanelLine({
+  w,
+  barColor,
+  used,
+  children,
+}: {
+  w: number;
+  barColor: string;
+  used: number;
+  children: ReactNode;
+}) {
+  return (
+    <Text backgroundColor={BG_PANEL}>
+      <Text color={barColor} bold>
+        {"▌ "}
+      </Text>
+      {children}
+      <Text backgroundColor={BG_PANEL}>{fill(w - 2, used)}</Text>
+    </Text>
+  );
+}
+
 function BlockTool({
   tool,
   icon,
@@ -125,55 +202,55 @@ function BlockTool({
   desc: string;
   pending: boolean;
 }) {
+  const { stdout } = useStdout();
+  const w = panelWidth(stdout?.columns);
+  const barColor = tool.isError ? "red" : "gray";
   const title =
     tool.toolName === "bash" ? oneLine(desc, 160) : `${tool.toolName} ${desc}`;
+  const titleClip = title.slice(0, w - 6);
+
+  const diff = tool.diff && tool.diff.length > 0 ? tool.diff : null;
+  const outLines =
+    !diff && !pending && tool.output ? clip(tool.output).split("\n") : [];
+
   return (
-    <Box
-      flexDirection="column"
-      borderStyle="round"
-      borderColor={tool.isError ? "red" : "gray"}
-      borderTop={false}
-      borderRight={false}
-      borderBottom={false}
-      paddingLeft={1}
-      marginTop={1}
-      marginBottom={1}
-    >
-      <Box>
-        <Text color={tool.isError ? "red" : "cyan"} bold>
+    <Box flexDirection="column" marginTop={1} marginBottom={1}>
+      <PanelLine w={w} barColor={barColor} used={2 + titleClip.length}>
+        <Text color={tool.isError ? "red" : "white"} bold backgroundColor={BG_PANEL}>
           {icon}{" "}
         </Text>
-        <Text bold>{title}</Text>
-        {pending && <Spinner label="" />}
-      </Box>
-      {tool.diff && tool.diff.length > 0 ? (
-        <DiffBody diff={tool.diff} />
-      ) : (
-        !pending &&
-        tool.output && (
-          <Text dimColor color={tool.isError ? "red" : undefined}>
-            {clip(tool.output)}
+        <Text bold backgroundColor={BG_PANEL}>
+          {titleClip}
+        </Text>
+      </PanelLine>
+
+      {pending && (
+        <PanelLine w={w} barColor={barColor} used={2 + pendingText(tool.toolName).length}>
+          <Text dimColor backgroundColor={BG_PANEL}>
+            ~ {pendingText(tool.toolName)}
           </Text>
-        )
+        </PanelLine>
       )}
-    </Box>
-  );
-}
 
-function DiffBody({ diff }: { diff: DiffLine[] }) {
-  return (
-    <Box flexDirection="column">
-      {diff.slice(0, 15).map((d, i) => (
-        <Text
-          key={i}
-          color={d.type === "add" ? "green" : d.type === "remove" ? "red" : undefined}
-          dimColor={d.type === "same"}
-        >
-          {d.type === "add" ? "+ " : d.type === "remove" ? "- " : "  "}
-          {d.text.slice(0, 100)}
-        </Text>
-      ))}
-      {diff.length > 15 && <Text dimColor>… {diff.length - 15} more lines</Text>}
+      {diff && diff.slice(0, 15).map((d, i) => <DiffLineRow key={i} d={d} w={w} />)}
+      {diff && diff.length > 15 && (
+        <PanelLine w={w} barColor={barColor} used={2 + 14}>
+          <Text dimColor backgroundColor={BG_PANEL}>
+            … {diff.length - 15} more
+          </Text>
+        </PanelLine>
+      )}
+
+      {outLines.map((ln, i) => {
+        const t = ln.slice(0, w - 2);
+        return (
+          <PanelLine key={i} w={w} barColor={barColor} used={t.length}>
+            <Text dimColor color={tool.isError ? "red" : undefined} backgroundColor={BG_PANEL}>
+              {t}
+            </Text>
+          </PanelLine>
+        );
+      })}
     </Box>
   );
 }

package/src/tui/Welcome.tsx

@@ -2,6 +2,7 @@ import { Box, Text } from "ink";
 import { currentThinking } from "../config.ts";
 import { WORDMARK } from "./wordmark.ts";
 import { PANEL, padRight } from "./theme.ts";
+import { CURRENT_VERSION } from "../version.ts";
 
 // Larghezza del pannello wordmark = riga più lunga + margini.
 const WM_W = Math.max(...WORDMARK.map((l) => l.length)) + 4;
@@ -19,6 +20,7 @@ interface Props {
   provider: string;
   model: string;
   sessionCount: number;
+  update?: string | null;
 }
 
 function Tip({ cmd, desc }: { cmd: string; desc: string }) {
@@ -34,9 +36,19 @@ function Tip({ cmd, desc }: { cmd: string; desc: string }) {
 
 // Branding-only: l'input è condiviso (gestito da App), così gli slash e
 // l'autocomplete funzionano anche dalla home.
-export function Welcome({ provider, model, sessionCount }: Props) {
+export function Welcome({ provider, model, sessionCount, update }: Props) {
   return (
     <Box flexDirection="column" marginBottom={1}>
+      {/* Banner aggiornamento (it. 28): discreto, solo se c'è una versione più recente */}
+      {update && (
+        <Box justifyContent="center" marginBottom={1}>
+          <Text color={ACCENT}>
+            interference {CURRENT_VERSION} → {update}
+          </Text>
+          <Text color={MUTED}> · run </Text>
+          <Text color={ACCENT}>/update</Text>
+        </Box>
+      )}
       {/* Header centrato: wordmark su pannello (sfondo reale via Text) + tagline */}
       <Box flexDirection="column" alignItems="center" marginBottom={1}>
         <Box flexDirection="column">
@@ -65,13 +77,16 @@ export function Welcome({ provider, model, sessionCount }: Props) {
         </Box>
       )}
 
-      {/* Tips (blocco, centrato) */}
+      {/* Tips (blocco, centrato) — i due comandi fondamentali in cima */}
       <Box flexDirection="column" alignItems="center" marginTop={1}>
+        <Box marginBottom={1}>
+          <Text color={MUTED}>Get started — connect a provider, then pick a model:</Text>
+        </Box>
         <Box flexDirection="column">
-          <Tip cmd="/help" desc="show all commands" />
-          <Tip cmd="/build" desc="switch to full-access mode" />
+          <Tip cmd="/provider" desc="connect a provider (add your API key)" />
+          <Tip cmd="/model" desc="choose the model to use" />
+          <Tip cmd="/help" desc="all commands" />
           <Tip cmd="/thinking" desc="set reasoning level" />
-          <Tip cmd="/init" desc="generate AGENTS.md" />
         </Box>
       </Box>
 

package/src/tui/__tests__/reasoning.test.ts

@@ -0,0 +1,24 @@
+import { describe, test, expect } from "bun:test";
+import { reasoningSummary } from "../reasoning.ts";
+
+describe("reasoningSummary (iter 23)", () => {
+  test("prima frase breve", () => {
+    expect(reasoningSummary("Devo controllare i file. Poi rispondo.")).toBe("Devo controllare i file.");
+  });
+
+  test("strip markdown iniziale e cap a 60", () => {
+    const long = "## " + "x".repeat(80);
+    const out = reasoningSummary(long);
+    expect(out.startsWith("x")).toBe(true);
+    expect(out.length).toBeLessThanOrEqual(61); // 60 + …
+    expect(out.endsWith("…")).toBe(true);
+  });
+
+  test("salta righe vuote, prende la prima significativa", () => {
+    expect(reasoningSummary("\n\n- Analizzo il loop")).toBe("Analizzo il loop");
+  });
+
+  test("testo vuoto → stringa vuota", () => {
+    expect(reasoningSummary("   \n  ")).toBe("");
+  });
+});