merge: dev8 → master — bulk-ack messaggi team (route ack-all + segna-tutti-letti) + normalizza escape \n nei messaggi/profilo (jht-notify-user)

Author: leopu00

agents/_tools/jht-notify-user

@@ -38,6 +38,19 @@ def resolve_db_path() -> str:
     return os.path.join(jht_home, "jobs.db")
 
 
+def interpret_escapes(text: str) -> str:
+    """Converte le escape letterali \\n \\t \\r in caratteri veri.
+
+    Gli agenti (LLM) scrivono `\\n\\n` come separatore di paragrafi in una
+    stringa singola, confidando che venga interpretato. `jht-telegram-send`
+    fa gia' questa conversione (vedi commento li', screenshot 2026-05-16);
+    senza la stessa conversione qui il body finiva in pending_user_messages
+    — e quindi in dashboard — coi 4 caratteri letterali `\\`, `n`, `\\`, `n`.
+    Interpretiamo solo le escape comuni, mai un decode generico fragile.
+    """
+    return text.replace("\\n", "\n").replace("\\t", "\t").replace("\\r", "\r")
+
+
 def _is_off_hours() -> bool:
     """True se la config ha working_hours e l'orario corrente e' fuori finestra.
 
@@ -164,6 +177,10 @@ def main() -> int:
         print("jht-notify-user: body vuoto", file=sys.stderr)
         return 1
 
+    # Normalizza una sola volta: il body interpretato finisce sia in DB
+    # (e quindi in dashboard web via cloud push) sia in Telegram, coerente.
+    body = interpret_escapes(args.body)
+
     db_path = resolve_db_path()
     if not os.path.exists(db_path):
         print(f"jht-notify-user: DB non trovato: {db_path}", file=sys.stderr)
@@ -173,7 +190,7 @@ def main() -> int:
         row_id = insert_pending(
             db_path,
             agent=args.agent,
-            body=args.body,
+            body=body,
             kind=args.kind,
             related_position_id=args.position_id,
         )
@@ -183,7 +200,7 @@ def main() -> int:
 
     delivered_via = "web"
     off_hours = _is_off_hours()
-    if not args.no_telegram and not off_hours and try_telegram(args.agent, args.body):
+    if not args.no_telegram and not off_hours and try_telegram(args.agent, body):
         delivered_via = "telegram"
     if off_hours:
         print(

shared/skills/_db.py

@@ -119,6 +119,7 @@ def ensure_schema(conn: sqlite3.Connection):
         source TEXT,
         jd_text TEXT,
         requirements TEXT,
+        jd_summary TEXT,
         found_by TEXT,
         found_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
         deadline TEXT,

shared/skills/db_update.py

@@ -81,6 +81,21 @@ def _guard_role_family(conn, raw, _active=None):
     return _SENTINEL, v
 
 
+def interpret_escapes(text):
+    """Converte le escape LETTERALI \\n \\t \\r in caratteri veri.
+
+    Gli agenti (LLM) scrivono `\\n\\n` come separatori di paragrafo dentro una
+    stringa singola passata come arg CLI. Senza questa conversione finirebbero
+    LETTERALI in DB e quindi in dashboard (i `\\n` resterebbero visibili come
+    testo). Coerente con jht-telegram-send / jht-notify-user. Applicato ai soli
+    campi free-text leggibili dall'utente (notes, jd_summary), non ai campi
+    scraped (jd_text/requirements).
+    """
+    if text is None:
+        return None
+    return text.replace("\\n", "\n").replace("\\t", "\t").replace("\\r", "\r")
+
+
 def update_position(args):
     conn = get_db()
     ensure_schema(conn)
@@ -106,15 +121,15 @@ def update_position(args):
         changed.append(f"status={args.status}")
     if args.notes:
         updates.append("notes = ?")
-        params.append(args.notes)
+        params.append(interpret_escapes(args.notes))
         changed.append(f"notes={args.notes[:40]}...")
     if args.jd_text:
         updates.append("jd_text = ?")
         params.append(args.jd_text)
         changed.append("jd_text")
     if args.jd_summary:
         updates.append("jd_summary = ?")
-        params.append(args.jd_summary)
+        params.append(interpret_escapes(args.jd_summary))
         changed.append("jd_summary")
     if args.requirements:
         updates.append("requirements = ?")

web/app/api/pending-messages/ack-all/route.ts

@@ -0,0 +1,66 @@
+import { NextResponse } from "next/server";
+import { requireAuth, isLocalRequest } from "@/lib/auth";
+import { isSupabaseConfigured } from "@/lib/workspace";
+import { getWorkspacePath } from "@/lib/workspace";
+import { createClient } from "@/lib/supabase/server";
+import { ackAllPendingMessagesLocal } from "@/lib/local-queries";
+
+export const dynamic = "force-dynamic";
+
+// Marca come letti TUTTI i messaggi web pendenti dell'utente in un colpo solo.
+// Stesso filtro della query che popola la card (delivered_via='web' e non
+// ancora ack): cosi' azzera esattamente cio' che la dashboard mostra. I DIGEST
+// del team si riaccumulano nel tempo e ackarli uno a uno non e' praticabile.
+// Idempotente: nessun messaggio pendente -> 200 ok=true, changed=0.
+export async function POST() {
+  const denied = await requireAuth();
+  if (denied) return denied;
+
+  // Local mode: SQLite. Lo stato verra' pushato al cloud al prossimo tick.
+  if (await isLocalRequest()) {
+    const ws = await getWorkspacePath();
+    if (!ws) {
+      return NextResponse.json(
+        { error: "workspace non trovato" },
+        { status: 500 },
+      );
+    }
+    try {
+      const changed = ackAllPendingMessagesLocal(ws);
+      return NextResponse.json({ ok: true, changed });
+    } catch (e) {
+      return NextResponse.json(
+        { error: `ack-all fallito: ${(e as Error).message}` },
+        { status: 500 },
+      );
+    }
+  }
+
+  // Cloud mode: Supabase con RLS. user_id vincola alle sole righe dell'utente.
+  if (!isSupabaseConfigured) {
+    return NextResponse.json(
+      { error: "Supabase non configurato" },
+      { status: 500 },
+    );
+  }
+  const supabase = await createClient();
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+  if (!user) {
+    return NextResponse.json({ error: "Non autenticato" }, { status: 401 });
+  }
+
+  const { data, error } = await supabase
+    .from("pending_user_messages")
+    .update({ acknowledged_at: new Date().toISOString() })
+    .eq("user_id", user.id)
+    .eq("delivered_via", "web")
+    .is("acknowledged_at", null)
+    .select("id");
+
+  if (error) {
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+  return NextResponse.json({ ok: true, changed: data?.length ?? 0 });
+}

web/app/components/PendingMessagesCard.tsx

@@ -145,6 +145,15 @@ const T: Record<string, Record<string, string>> = {
     fr: "Marquer comme lu",
     pt: "Marcar como lido",
   },
+  mark_all_read: {
+    it: "Segna tutti come letti",
+    en: "Mark all as read",
+    hu: "Összes megjelölése olvasottként",
+    es: "Marcar todo como leído",
+    de: "Alle als gelesen markieren",
+    fr: "Tout marquer comme lu",
+    pt: "Marcar tudo como lido",
+  },
   reply: {
     it: "Rispondi →",
     en: "Reply →",
@@ -227,6 +236,15 @@ const KIND_LABEL_KEY: Record<PendingMessageKind, string> = {
   alert: "kind_alert",
 };
 
+// Alcuni messaggi salvati prima del fix in jht-notify-user contengono le
+// escape LETTERALI `\n`/`\t` (l'agente le scrive come separatori di paragrafo
+// in una stringa singola). pre-wrap rende solo i newline VERI, quindi senza
+// questa normalizzazione si vedrebbe il testo "\n\n". Difensivo e idempotente:
+// i newline gia' veri restano invariati.
+function normalizeBody(s: string): string {
+  return s.replace(/\\r\\n|\\n/g, "\n").replace(/\\t/g, "\t");
+}
+
 export default function PendingMessagesCard({ initialMessages }: Props) {
   // L'array e' state interno: ack/reply rimuovono il messaggio dalla lista
   // senza dover ricaricare la pagina. Il polling per nuove notifiche verra'
@@ -273,6 +291,24 @@ export default function PendingMessagesCard({ initialMessages }: Props) {
     });
   }
 
+  async function handleAckAll() {
+    setError(null);
+    startTransition(async () => {
+      try {
+        const res = await fetch(`/api/pending-messages/ack-all`, {
+          method: "POST",
+        });
+        if (!res.ok) {
+          const body = await res.json().catch(() => ({}));
+          throw new Error(body.error ?? `HTTP ${res.status}`);
+        }
+        setMessages([]);
+      } catch (e) {
+        setError((e as Error).message);
+      }
+    });
+  }
+
   async function handleReply(id: string) {
     const reply = replyText.trim();
     if (!reply) {
@@ -304,9 +340,21 @@ export default function PendingMessagesCard({ initialMessages }: Props) {
     <div className="mb-8" style={{ animation: "fade-in 0.35s ease both" }}>
       <div className="flex items-center justify-between mb-4">
         <span className="section-label">{tr("section_title")}</span>
-        <span className="text-[10px] font-semibold tracking-widest uppercase text-[var(--color-dim)]">
-          {tr("unread").replace("{n}", String(messages.length))}
-        </span>
+        <div className="flex items-center gap-3">
+          <span className="text-[10px] font-semibold tracking-widest uppercase text-[var(--color-dim)]">
+            {tr("unread").replace("{n}", String(messages.length))}
+          </span>
+          {messages.length > 1 && (
+            <button
+              type="button"
+              onClick={handleAckAll}
+              disabled={pending}
+              className="text-[10px] font-semibold tracking-widest uppercase text-[var(--color-muted)] hover:text-[var(--color-bright)] transition-colors disabled:opacity-50"
+            >
+              {tr("mark_all_read")}
+            </button>
+          )}
+        </div>
       </div>
 
       {error && (
@@ -377,7 +425,7 @@ export default function PendingMessagesCard({ initialMessages }: Props) {
                     className="text-[12px] text-[var(--color-base)] m-0 mb-2 leading-relaxed"
                     style={{ whiteSpace: "pre-wrap" }}
                   >
-                    {m.body}
+                    {normalizeBody(m.body)}
                   </p>
                   {m.related_position_id && (
                     <Link

web/app/components/ProfileBlockRenderer.tsx

@@ -20,11 +20,18 @@ type Dist = { label?: string; value?: number };
 
 const asArray = (v: unknown): unknown[] => (Array.isArray(v) ? v : []);
 
+// Le narrative del profilo sono LLM-generated: possono contenere escape
+// LETTERALI `\n`/`\t` (i due caratteri, non whitespace) che pre-wrap NON
+// interpreta. Le normalizziamo a render, come in PendingMessagesCard.
+function normalizeNarrative(s: string): string {
+  return s.replace(/\\r\\n|\\n/g, "\n").replace(/\\t/g, "\t");
+}
+
 function Narrative({ text }: { text: unknown }) {
   const s = typeof text === "string" ? text : JSON.stringify(text);
   return (
     <p className="text-[12px] text-[var(--color-bright)] leading-relaxed whitespace-pre-wrap">
-      {s}
+      {normalizeNarrative(s)}
     </p>
   );
 }

web/lib/local-queries.ts

@@ -1625,6 +1625,23 @@ export function ackPendingMessageLocal(ws: string, id: string): boolean {
   return result.changes > 0;
 }
 
+// Marca come letti tutti i messaggi web pendenti in un colpo solo. Stesso
+// filtro di getPendingMessagesLocal (delivered_via='web' AND non ack) cosi'
+// azzera esattamente cio' che la dashboard mostra. Ritorna il n. di righe.
+export function ackAllPendingMessagesLocal(ws: string): number {
+  const db = getDb(ws);
+  const result = db
+    .prepare(
+      `
+    UPDATE pending_user_messages
+    SET acknowledged_at = CURRENT_TIMESTAMP
+    WHERE delivered_via = 'web' AND acknowledged_at IS NULL
+  `,
+    )
+    .run();
+  return result.changes;
+}
+
 export function replyPendingMessageLocal(
   ws: string,
   id: string,