chore: untrack runtime state files

approved-tasks.json, dashboard/status.json, anaf-monitor/monitor.log
are auto-modified by background processes (heartbeat, cron jobs, ANAF
monitor). Untracking them stops the noisy "auto-commit from dashboard"
churn. Files stay on disk; readers (router._load_approved_tasks etc.)
already handle missing files by returning empty defaults.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.gitignore

@@ -24,3 +24,8 @@ credentials/
 memory.bak/
 .use_openrouter
 .gstack/
+
+# Runtime state — auto-modified by dashboard/cron/heartbeat
+approved-tasks.json
+dashboard/status.json
+tools/anaf-monitor/monitor.log

approved-tasks.json

@@ -1,82 +0,0 @@
-{
-  "projects": [
-    {
-      "name": "romfast-website",
-      "description": "analizeaza paginile din website si propune 1-3 pagini noi sau modificare de pagini cu ce ar face website-ul firmei mele Romfast (vinde ERP ROA) mai util, informational, educativ, cu scopul de a atrage lead-uri informate, calde",
-      "status": "cancelled",
-      "planning_session_id": null,
-      "final_plan_path": null,
-      "proposed_at": "2026-04-26T18:53:47.597827+00:00",
-      "approved_at": null,
-      "started_at": null,
-      "pid": null
-    },
-    {
-      "name": "space-booking",
-      "description": "vreau sa pornesti aplicatia si sa testezi frontend in browser",
-      "status": "cancelled",
-      "planning_session_id": null,
-      "final_plan_path": null,
-      "proposed_at": "2026-04-26T19:12:15.605405+00:00",
-      "approved_at": null,
-      "started_at": null,
-      "pid": null
-    },
-    {
-      "name": "roa2web-anaf-notificari",
-      "description": "Integrare alerte ANAF Monitor direct \u00een roa2web: c\u00e2nd monitor_v2.py detecteaz\u0103 modific\u0103ri la D406/D394/D100/D390/E-Factura, trimite notificare automat\u0103 prin Telegram bot existent \u00een roa2web. UI simplu \u00een dashboard pentru vizualizare modific\u0103ri recente.",
-      "status": "cancelled",
-      "proposed_at": "2026-04-27T21:01:29.004348",
-      "approved_at": null,
-      "started_at": null,
-      "pid": null
-    },
-    {
-      "name": "roa2web-playwright-qa",
-      "description": "QA automat pentru roa2web cu Playwright CLI + Claude Code: set de teste care verific\u0103 paginile principale (balan\u021b\u0103, facturi, trezorerie), detecteaz\u0103 regresii vizuale \u0219i func\u021bionale, raporteaz\u0103 \u00een dashboard. Rulare automat\u0103 la fiecare deploy.",
-      "status": "cancelled",
-      "proposed_at": "2026-04-27T21:01:29.004348",
-      "approved_at": null,
-      "started_at": null,
-      "pid": null
-    },
-    {
-      "name": "chatbot-maria-txt-converter",
-      "description": "Script simplu care converte\u0219te fi\u0219iere TXT (scrise de angajatul nou) \u00een Markdown structurat pentru document store Flowise (chatbot Maria). Monitorizeaz\u0103 un folder, converte\u0219te automat \u0219i actualizeaz\u0103 document store.",
-      "status": "cancelled",
-      "proposed_at": "2026-04-27T21:01:29.004348",
-      "approved_at": null,
-      "started_at": null,
-      "pid": null
-    },
-    {
-      "name": "roa2web-d406-validator",
-      "description": "Validare structura XML declaratii ANAF (D406/D394) in roa2web inainte de submitere - reduce apeluri suport pentru erori respingere",
-      "status": "pending",
-      "proposed_at": "2026-04-29T21:02:03.132347",
-      "approved_at": null,
-      "started_at": null,
-      "pid": null
-    },
-    {
-      "name": "roa2web-valuta-taxare-inversa",
-      "description": "Feature facturare in valuta cu taxare inversa in roa2web - curs BNR auto + calcul TVA inversare pentru clienti care factureaza in UE",
-      "status": "pending",
-      "proposed_at": "2026-04-29T21:02:03.132347",
-      "approved_at": null,
-      "started_at": null,
-      "pid": null
-    },
-    {
-      "name": "chatbot-maria-ternary-model",
-      "description": "Upgrade chatbot Maria cu model ternary local Bonsai 8B pe LXC 104 Ollama - raspunsuri mai bune fara dependenta Groq API, 2GB RAM suficient",
-      "status": "pending",
-      "proposed_at": "2026-04-29T21:02:03.132347",
-      "approved_at": null,
-      "started_at": null,
-      "pid": null
-    }
-  ],
-  "last_updated": "2026-04-29T21:02:03.132347",
-  "version": 7
-}

dashboard/handlers/eco.py

@@ -155,7 +155,7 @@ class EcoHandlers:
                     if isinstance(content, str):
                         text = content.replace('[EXTERNAL CONTENT]\n', '').replace('\n[END EXTERNAL CONTENT]', '').strip()
                         if text:
-                            messages.append({'role': 'user', 'text': text[:2000]})
+                            messages.append({'role': 'user', 'text': text[:20000]})
                 elif t == 'assistant':
                     msg = d.get('message', {})
                     content = msg.get('content', '')
@@ -163,9 +163,9 @@ class EcoHandlers:
                         parts = [block['text'] for block in content if block.get('type') == 'text']
                         text = '\n'.join(parts).strip()
                         if text:
-                            messages.append({'role': 'assistant', 'text': text[:2000]})
+                            messages.append({'role': 'assistant', 'text': text[:20000]})
                     elif isinstance(content, str) and content.strip():
-                        messages.append({'role': 'assistant', 'text': content[:2000]})
+                        messages.append({'role': 'assistant', 'text': content[:20000]})
 
             self.send_json({'messages': messages})
         except Exception as e:

dashboard/handlers/projects.py

@@ -43,6 +43,7 @@ import hashlib
 import json
 import logging
 import os
+import re
 import subprocess
 import sys
 import time
@@ -248,6 +249,102 @@ def _last_message_preview(slug: str) -> str:
     return best[:200]
 
 
+# ─── planning transcript helpers ──────────────────────────────────────
+
+
+_EXTERNAL_CONTENT_RE = re.compile(
+    r"^\s*\[EXTERNAL CONTENT\]\s*\n(.*)\n\[END EXTERNAL CONTENT\]\s*$",
+    re.DOTALL,
+)
+_COMMAND_ARGS_RE = re.compile(r"<command-args>(.*?)</command-args>", re.DOTALL)
+
+
+def _planning_jsonl_path(slug: str, session_id: str) -> Path | None:
+    """Path to the Claude CLI JSONL transcript for a planning session.
+
+    PlanningSession runs with cwd = `~/workspace/<slug>/` if it exists, else
+    falls back to the echo-core repo root (see `PlanningSession.cwd`).
+    Claude CLI stores transcripts under
+    `~/.claude/projects/<encoded-cwd>/<session_id>.jsonl`, where encoded-cwd
+    is the absolute path with `/` replaced by `-`.
+    """
+    if not session_id:
+        return None
+    workspace = constants.WORKSPACE_DIR / slug
+    cwd = workspace if workspace.is_dir() else constants.BASE_DIR
+    encoded = str(cwd).replace("/", "-")
+    return Path.home() / ".claude" / "projects" / encoded / f"{session_id}.jsonl"
+
+
+def _clean_user_text(text: str) -> str:
+    """Strip wrappers Echo adds around user input sent to the planning subprocess."""
+    m = _EXTERNAL_CONTENT_RE.match(text)
+    if m:
+        text = m.group(1).strip()
+    if "<command-name>" in text:
+        m = _COMMAND_ARGS_RE.search(text)
+        if m:
+            text = m.group(1).strip()
+    return text
+
+
+def _extract_text_blocks(content) -> str:
+    """Concatenate `text`-type blocks from a Claude `message.content` field."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "text":
+                t = block.get("text") or ""
+                if t:
+                    parts.append(t)
+        return "\n\n".join(parts)
+    return ""
+
+
+def _load_planning_history(slug: str, session_id: str | None) -> list[dict]:
+    """Parse the Claude session JSONL into a `[{role, text}, ...]` chat history.
+
+    Skips queue / system / tool-result entries. Empty list on any structural
+    problem so callers can fall back to `last_text_excerpt`.
+    """
+    if not session_id:
+        return []
+    path = _planning_jsonl_path(slug, session_id)
+    if path is None or not path.exists():
+        return []
+    history: list[dict] = []
+    try:
+        with path.open(encoding="utf-8") as fh:
+            for raw in fh:
+                raw = raw.strip()
+                if not raw:
+                    continue
+                try:
+                    entry = json.loads(raw)
+                except json.JSONDecodeError:
+                    continue
+                etype = entry.get("type")
+                if etype not in ("user", "assistant"):
+                    continue
+                if etype == "user" and "toolUseResult" in entry:
+                    continue
+                if entry.get("isMeta"):
+                    continue
+                msg = entry.get("message") or {}
+                text = _extract_text_blocks(msg.get("content"))
+                if etype == "user":
+                    text = _clean_user_text(text)
+                text = (text or "").strip()
+                if not text:
+                    continue
+                history.append({"role": etype, "text": text})
+    except OSError:
+        return []
+    return history
+
+
 # ─── version helpers ──────────────────────────────────────────────────
 
 
@@ -929,6 +1026,8 @@ class ProjectsHandlers:
                 final_plan_text = fp.read_text(encoding="utf-8", errors="replace")
         except OSError:
             pass
+        session_id = (state or {}).get("session_id") or ""
+        history = _load_planning_history(slug, session_id)
         self.send_json({
             "slug": slug,
             "phase": (state or {}).get("phase"),
@@ -936,7 +1035,7 @@ class ProjectsHandlers:
             "last_text_excerpt": (state or {}).get("last_text_excerpt") or "",
             "final_plan_path": final_plan_path,
             "final_plan": final_plan_text,
-            "history": [],  # reserved for future per-turn JSONL sidecar
+            "history": history,
         })
 
     # ── POST /api/projects/<slug>/plan/finalize ───────────────────

dashboard/status.json

@@ -1,19 +0,0 @@
-{
-  "git": {
-    "status": "4 fișiere",
-    "clean": false,
-    "files": 4
-  },
-  "lastReport": {
-    "type": "evening",
-    "summary": "notes.html îmbunătățit (filtre colorate), rețetă salvată",
-    "time": "30 Jan 2026, 22:00"
-  },
-  "anaf": {
-    "ok": true,
-    "status": "OK",
-    "message": "Nicio modificare detectată",
-    "lastCheck": "30 Apr 2026, 16:00",
-    "changesCount": 0
-  }
-}

dashboard/workspace.html

@@ -1954,18 +1954,29 @@
         // ──────────────────────────────────────────
         const PHASES = ['office-hours', 'ceo-review', 'eng-review'];
 
+        function normalizePhase(phase) {
+            return (phase || '').replace(/^\//, '').replace(/^plan-/, '');
+        }
+
         function setPhase(phase, completed) {
             state.planning.phase = phase;
             state.planning.phasesCompleted = completed || [];
+            const norm = normalizePhase(phase);
+            const completedNorm = (completed || []).map(normalizePhase);
             const steps = phaseStepper.querySelectorAll('.phase-step');
             steps.forEach(step => {
                 const ph = step.dataset.phase;
                 step.classList.remove('active', 'complete');
-                if ((completed || []).indexOf(ph) >= 0) step.classList.add('complete');
-                if (ph === phase) step.classList.add('active');
+                if (completedNorm.indexOf(ph) >= 0) step.classList.add('complete');
+                if (ph === norm) step.classList.add('active');
             });
         }
 
+        function stripPhaseMarkers(text) {
+            if (!text) return text;
+            return text.replace(/\s*\nPHASE_STATUS:\s*(ready_to_advance|needs_input)\s*$/, '').trimEnd();
+        }
+
         function renderMarkdown(text) {
             if (!text) return '';
             try {
@@ -1977,15 +1988,16 @@
         }
 
         function appendMessage(role, content) {
-            state.planning.messages.push({ role, content, ts: Date.now() });
+            const display = role === 'assistant' ? stripPhaseMarkers(content) : content;
+            state.planning.messages.push({ role, content: display, ts: Date.now() });
             const msg = document.createElement('div');
             msg.className = 'chat-msg ' + role;
             const bubble = document.createElement('div');
             bubble.className = 'chat-bubble';
             if (role === 'assistant') {
-                bubble.innerHTML = renderMarkdown(content);
+                bubble.innerHTML = renderMarkdown(display);
             } else {
-                bubble.textContent = content;
+                bubble.textContent = display;
             }
             msg.appendChild(bubble);
             chatStream.appendChild(msg);
@@ -2075,14 +2087,24 @@
                 if (tRes.ok) {
                     const data = await safeJson(tRes);
                     if (data) {
-                        if (data.last_text_excerpt) {
+                        let rendered = false;
+                        if (Array.isArray(data.history) && data.history.length > 0) {
+                            for (const m of data.history) {
+                                if (m && m.text) appendMessage(m.role || 'assistant', m.text);
+                            }
+                            rendered = true;
+                        } else if (data.last_text_excerpt) {
                             appendMessage('assistant', data.last_text_excerpt);
+                            rendered = true;
                         }
                         const phasesCompleted = data.phases_completed || [];
                         const phase = data.phase || 'office-hours';
                         setPhase(phase === '__complete__' ? null : phase, phasesCompleted);
                         // If we already have content, we're resuming
-                        if (data.last_text_excerpt) {
+                        if (rendered) {
+                            requestAnimationFrame(() => {
+                                chatStream.scrollTop = chatStream.scrollHeight;
+                            });
                             try { composerInput.focus(); } catch (e) {}
                             return;
                         }
@@ -2189,6 +2211,9 @@
                         }
                         setPhase(data.phase === '__complete__' ? null : data.phase, completed);
                     }
+                    if (data.phase_ready) {
+                        await autoAdvancePhase(slug);
+                    }
                 }
             } catch (err) {
                 removeTypingIndicator();
@@ -2203,6 +2228,42 @@
             }
         }
 
+        async function autoAdvancePhase(slug) {
+            const prevPhase = state.planning.phase;
+            appendMessage('assistant', '_Faza completă. Pornesc subprocess pentru următoarea fază..._');
+            appendTypingIndicator();
+            startElapsedCounter();
+            try {
+                const res = await apiFetch('/echo/api/projects/' + encodeURIComponent(slug) + '/plan/advance', {
+                    method: 'POST',
+                });
+                removeTypingIndicator();
+                stopElapsedCounter();
+                if (!res.ok) {
+                    const d = await safeJson(res);
+                    appendMessage('assistant', '_Nu am putut avansa: ' + ((d && d.message) || ('HTTP ' + res.status)) + '_');
+                    return;
+                }
+                const data = await safeJson(res);
+                if (!data) return;
+                const completed = state.planning.phasesCompleted.slice();
+                if (prevPhase && !completed.includes(prevPhase)) completed.push(prevPhase);
+                if (data.completed) {
+                    setPhase(null, completed);
+                    if (data.message) appendMessage('assistant', data.message);
+                } else {
+                    if (data.message) appendMessage('assistant', data.message);
+                    setPhase(data.phase, completed);
+                }
+            } catch (err) {
+                removeTypingIndicator();
+                stopElapsedCounter();
+                if (err.message !== 'unauthorized') {
+                    appendMessage('assistant', '_Eroare la avans fază: ' + (err.message || err) + '_');
+                }
+            }
+        }
+
         planCancelBtn.addEventListener('click', async () => {
             const slug = state.planning.slug;
             if (!slug) { closeModal(planModal); return; }

memory/kb/facebook/2026-05-05_5-1k-views-1-8k-reactions-todo-movimento-bate-o-pe.md

@@ -0,0 +1,42 @@
+# TODO MOVIMENTO — Cântec cercetași brazilian
+
+**Sursa:** https://www.facebook.com/share/r/18sbi6BZ6r/
+**Data:** 2026-05-05
+**Creator:** Canal do Chefe Wil
+**Format:** Reel Facebook
+**Tags:** @cercetasi @jocuri @cantece
+
+---
+
+## TL;DR
+
+Cântec de mișcare cumulativ pentru cercetași brazilieni. La fiecare strofă adaugi un nou segment al corpului și mimezi toate cele anterioare. Potrivit pentru activități de grup, energizare.
+
+---
+
+## Text original (portugheză)
+
+> **Instrucțiuni:** bate o pé direito, o esquerdo e palmas, durante toda a música, 4x antes de cada frase em mudo
+> *(bate piciorul drept, stângul și aplaudă, pe toată muzica, de 4x înainte de fiecare frază silențioasă)*
+
+Todo movimento, baila, baila, baila
+Com um dedo, o dedo, e o outro dedo *(mostra os membros a frente)*
+Todo movimento, baila, baila, baila
+Com um dedo, o dedo, e o outro dedo
+Com uma mão, a mão, e a outra mão *(mostra os membros a frente)*
+
+*(Assim vai acrescentando: os braços, os cotos/cotovelos, os ombros, os pés, os joelhos, as pernas, as coxas, a bunda, a barriga e a cabeça)*
+
+---
+
+## Traducere română
+
+> **Instrucțiuni:** bate piciorul drept, stângul și aplaudă, pe toată durata muzicii, de 4x înainte de fiecare frază silențioasă
+
+Toată mișcarea, dansează, dansează, dansează
+Cu un deget, degetul, și celălalt deget *(arată membrele în față)*
+Toată mișcarea, dansează, dansează, dansează
+Cu un deget, degetul, și celălalt deget
+Cu o mână, mâna, și cealaltă mână *(arată membrele în față)*
+
+*(Se adaugă progresiv: brațele, coatele, umerii, picioarele, genunchii, gambele, coapsele, fundul, burta și capul)*

memory/kb/index.json

@@ -1,5 +1,149 @@
 {
   "notes": [
+    {
+      "file": "notes-data/facebook/2026-05-05_5-1k-views-1-8k-reactions-todo-movimento-bate-o-pe.md",
+      "title": "TODO MOVIMENTO — Cântec cercetași brazilian",
+      "date": "2026-05-05",
+      "tags": [],
+      "domains": [],
+      "types": [],
+      "category": "facebook",
+      "project": null,
+      "subdir": null,
+      "video": "",
+      "tldr": "Cântec de mișcare cumulativ pentru cercetași brazilieni. La fiecare strofă adaugi un nou segment al corpului și mimezi toate cele anterioare. Potrivit pentru activități de grup, energizare."
+    },
+    {
+      "file": "notes-data/youtube/2026-05-05_scott-galloway-ai-wasnt-built-for-you.md",
+      "title": "Scott Galloway: AI Wasn't Built For You. The Rich Don't Need You Anymore!",
+      "date": "2026-05-05",
+      "tags": [],
+      "domains": [
+        "growth",
+        "work"
+      ],
+      "types": [],
+      "category": "youtube",
+      "project": null,
+      "subdir": null,
+      "video": "",
+      "tldr": "Scott Galloway (profesor NYU, economist) argumentează că AI-ul este în primul rând un instrument de concentrare a avuției, nu unul democratic — percepția pozitivă despre AI corelează direct cu avuția...."
+    },
+    {
+      "file": "notes-data/youtube/2026-05-04_oz-pearlman-mentalist-read-people.md",
+      "title": "Oz Pearlman (Mentalist): This Small Mistake Makes People Dislike You! They Do This, They're Lying!",
+      "date": "2026-05-04",
+      "tags": [],
+      "domains": [
+        "growth"
+      ],
+      "types": [
+        "coaching"
+      ],
+      "category": "youtube",
+      "project": null,
+      "subdir": null,
+      "video": "",
+      "tldr": "Oz Pearlman — mentalist de 30 de ani, fostul analist de pe Wall Street — explică că nu citește mințile, ci oamenii. Succesul lui vine din aceleași principii pe care le poate aplica oricine: fă-l pe ce..."
+    },
+    {
+      "file": "notes-data/youtube/2026-05-04_oz-pearlman-reading-minds-ted.md",
+      "title": "The Art of Reading Minds | Oz Pearlman | TED",
+      "date": "2026-05-04",
+      "tags": [],
+      "domains": [],
+      "types": [],
+      "category": "youtube",
+      "project": null,
+      "subdir": null,
+      "video": "",
+      "tldr": "Oz Pearlman, considerat cel mai mare mentalist din lume, demontează mitul că \"citit gânduri\" e talent înnăscut. E o abilitate învățată în 30 de ani: observi oamenii, nu gândurile lor. Prezintă două te..."
+    },
+    {
+      "file": "notes-data/youtube/2026-05-03_ai-coding-dev-team.md",
+      "title": "What 6 months of AI coding did to my dev team",
+      "date": "2026-05-03",
+      "tags": [],
+      "domains": [
+        "work",
+        "growth"
+      ],
+      "types": [],
+      "category": "youtube",
+      "project": null,
+      "subdir": null,
+      "video": "",
+      "tldr": "CEO-ul unei echipe de 20 de developeri descrie ce s-a schimbat în 6 luni de coding cu AI (Claude Code, Cursor). Concluzia: bottleneck-ul nu mai e scrierea codului, ci specificarea lui. Munca s-a mutat..."
+    },
+    {
+      "file": "notes-data/projects/samsung-990-pro-firmware-update.md",
+      "title": "Samsung 990 PRO Firmware Update",
+      "date": "2026-05-02",
+      "tags": [],
+      "domains": [],
+      "types": [],
+      "category": "projects",
+      "project": null,
+      "subdir": null,
+      "video": "",
+      "tldr": ""
+    },
+    {
+      "file": "notes-data/youtube/2026-05-02_karpathy-startups-2026.md",
+      "title": "Karpathy Just Told Us What Startups To Build For 2026",
+      "date": "2026-05-02",
+      "tags": [],
+      "domains": [
+        "work",
+        "growth"
+      ],
+      "types": [],
+      "category": "youtube",
+      "project": null,
+      "subdir": null,
+      "video": "",
+      "tldr": "Andrej Karpathy (fost OpenAI, Tesla Autopilot, inventatorul \"vibe coding\") a dat un talk în care spune că modul în care construim software s-a schimbat fundamental. Dacă tot ce faci e să învelești în ..."
+    },
+    {
+      "file": "notes-data/youtube/2026-05-02_samsung-ssds-dying.md",
+      "title": "Samsung SSDs Are Dying",
+      "date": "2026-05-02",
+      "tags": [
+        "ssd",
+        "samsung",
+        "hardware"
+      ],
+      "domains": [
+        "work"
+      ],
+      "types": [],
+      "category": "youtube",
+      "project": null,
+      "subdir": null,
+      "video": "",
+      "tldr": "Samsung 980 Pro și 990 Pro SSD-urile au un bug de firmware care distruge durata de viață — 50% din HP dispare după o lună. Fix rapid: update firmware la versiunea `5B2QGXA7` prin Samsung Magician."
+    },
+    {
+      "file": "notes-data/youtube/2026-05-02_claude-limit-chatgpt-habit.md",
+      "title": "Your Claude Limit Burns In 90 Minutes Because Of One ChatGPT Habit",
+      "date": "2026-05-02",
+      "tags": [
+        "token-management",
+        "claude",
+        "ai-efficiency",
+        "agents"
+      ],
+      "domains": [
+        "work",
+        "growth"
+      ],
+      "types": [],
+      "category": "youtube",
+      "project": null,
+      "subdir": null,
+      "video": "",
+      "tldr": "Videoclipul e despre cum obiceiurile proaste de folosire a AI-ului (ChatGPT, Claude, Gemini) ard tokens inutil — și cum le poți reduce de 8-10x fără să pierzi calitate. Autorul (Nate) a construit un \"..."
+    },
     {
       "file": "notes-data/emails/2026-04-30_fwd-newsletter-16-din-2026.md",
       "title": "Fwd: Newsletter 16 din 2026",
@@ -8592,8 +8736,8 @@
       "title": "Proiect: Vending Master - Integrare Website → ROA",
       "date": "2026-01-30",
       "tags": [
-        "integrare",
-        "vending-master"
+        "vending-master",
+        "integrare"
       ],
       "domains": [
         "work"
@@ -9073,11 +9217,11 @@
     }
   ],
   "stats": {
-    "total": 521,
+    "total": 530,
     "by_domain": {
-      "work": 164,
+      "work": 169,
       "health": 98,
-      "growth": 234,
+      "growth": 239,
       "sprijin": 39,
       "scout": 8
     },
@@ -9087,14 +9231,14 @@
       "conversations": 0,
       "emails": 19,
       "exercitii": 4,
-      "facebook": 1,
+      "facebook": 2,
       "health": 6,
       "insights": 46,
-      "projects": 233,
+      "projects": 234,
       "reflectii": 3,
       "retete": 1,
       "tools": 7,
-      "youtube": 106,
+      "youtube": 113,
       "memory": 43
     }
   },

memory/kb/projects/samsung-990-pro-firmware-update.md

@@ -0,0 +1,24 @@
+---
+name: Samsung 990 PRO firmware update — pvemini
+description: Task pending: update firmware 5B2QJXD7 → 8B2QJXD7 pe cele 2x Samsung 990 PRO 2TB de pe pvemini
+type: project
+---
+
+# Samsung 990 PRO Firmware Update
+
+**Nod:** pvemini (10.0.20.201)
+**Drive-uri:** nvme0n1 + nvme1n1 (Samsung 990 PRO 2TB)
+**Firmware curent:** 5B2QJXD7
+**Firmware țintă:** 8B2QJXD7 (dec 2025 — stabilitate citire)
+
+**Why:** Firmware outdated cu 3 versiuni. Health OK momentan (97% viață, 0 erori), dar update recomandat preventiv.
+
+**How to apply:** La fereastră de maintenance (necesită reboot pvemini). Procedură: USB bootabil cu ISO Samsung sau fwupd.
+
+## Pași
+
+1. Descarcă ISO firmware 990 PRO 8B2QJXD7 de pe [semiconductor.samsung.com](https://semiconductor.samsung.com/consumer-storage/support/tools/)
+2. Scrie pe USB: `dd if=samsung_firmware.iso of=/dev/sdX bs=4M`
+3. Planifică maintenance window (pvemini reboot → VM/LXC migrate sau oprire)
+4. Boot de pe USB → update ambele drive-uri
+5. Verificare post-update: `smartctl -i /dev/nvme0n1` și `nvme1n1`

memory/kb/youtube/2026-05-02_claude-limit-chatgpt-habit.md

@@ -0,0 +1,95 @@
+# Your Claude Limit Burns In 90 Minutes Because Of One ChatGPT Habit
+
+- **URL:** https://youtu.be/5ztI_dbj6ek
+- **Durata:** 26:35
+- **Data:** 2026-05-02
+- **Tags:** @work @growth #token-management #claude #ai-efficiency #agents
+
+---
+
+## TL;DR
+
+Videoclipul e despre cum obiceiurile proaste de folosire a AI-ului (ChatGPT, Claude, Gemini) ard tokens inutil — și cum le poți reduce de 8-10x fără să pierzi calitate. Autorul (Nate) a construit un "Stupid Button" care auditează pattern-urile de utilizare și identifică risipa. Modelele nu sunt scumpe — obiceiurile tale sunt.
+
+---
+
+## Puncte cheie
+
+### 1. Formatele de fișiere ucid bugetul de tokens
+- PDF raw: 100k+ tokens pentru 4.500 cuvinte de conținut (overhead header/footer/metadata)
+- Markdown: 4-6k tokens pentru același conținut — **economie 20x**
+- Convertire gratuita: orice serviciu online sau direct Claude
+- Screenshots = groaznic pentru tokens. Copy-paste text direct.
+
+### 2. Nu sprawla conversatiile
+- La fiecare turn, modelul reciteste INTREAGA conversatie
+- 20-30 turns = context window umplut, model "drift", scadere calitate
+- **Regula:** sesiune noua la 10-15 turns
+- **Doua moduri separate:** gathering info vs. executie. Nu le amesteca.
+
+### 3. Model selection inteligenta
+- **Opus:** rationament, decizii complexe, arhitectura
+- **Sonnet:** executie, coding, debugging
+- **Haiku:** formatare, polish, taskuri simple
+- Nu folosi Ferrari la cumparaturi. Opus nu pentru orice.
+
+### 4. Auditeaza plugin-urile si conectorii
+- Fiecare plugin = tokens incarcati la FIECARE sesiune
+- Un utilizator a raportat 50k tokens consumati inainte de primul cuvant scris
+- Daca nu il folosesti activ → sterge-l. "Barnacle on a ship"
+
+### 5. Prompt caching (pentru API / agenti)
+- Cache hits Opus: **$0.50/M vs $5/M standard = 90% discount**
+- Cache-uieste: system prompt, tool definitions, reference docs
+- Daca nu faci asta, arunci banii pe fereastra
+
+### 6. Web search eficient
+- Perplexity MCP vs Claude native search: 10-15k tokens mai putin per search
+- De 5x mai rapid + citations structurate
+- MCP = magic pentru token management la search
+
+### 7. Cei 5 Comandamenti pentru Agenti
+1. **Index references** — nu dump documente intregi in context
+2. **Pre-proceseaza** — documentul trebuie sa ajunga ready-to-use, nu ready-to-read
+3. **Cache stable context** — system prompts, tool defs, persona, reference docs
+4. **Scope minim** — un planning agent nu are nevoie de intreaga codebase
+5. **Masoara** — daca nu stii cost per call, optimizezi orb
+
+---
+
+## Estimare economii reale
+
+| Workflow | Input tokens | Output tokens | Cost estimat |
+|---------|-------------|---------------|-------------|
+| Sloppy (PDF raw, 30 turns, Opus tot) | 800k-1M | 150-200k | $8-10 |
+| Clean (markdown, 10-15 turns/session, model mix) | 100-150k | 50-80k | ~$1 |
+
+**Economie: 8-10x** pentru acelasi rezultat.
+
+---
+
+## Quote-uri
+
+> "Frontier AI can be absurdly cheap when you know what you're doing. The models are not expensive, it's your habits that cost a lot."
+
+> "Use Opus for reasoning and Sonnet for execution and Haiku for polish."
+
+> "Cache hits on Opus cost 50 cents per million versus $5 per million standard."
+
+> "Models perform worse when they're drowning in irrelevant context."
+
+> "You cannot improve what you do not measure."
+
+> "Your mistakes scale with the price of intelligence."
+
+> "As models get more intelligent, we can lean out the context window initially because we can trust the model to retrieve better."
+
+---
+
+## Actiuni practice (pentru Marius)
+
+- [ ] Audit plugins/skills active in Claude Code — `/context` command verifica ce se incarca
+- [ ] Sesiuni noi mai des in Claude Code (10-15 turns maxim)
+- [ ] Pentru Ralph agents: verifica daca system prompt-ul e caches
+- [ ] Web search via Perplexity MCP in loc de Claude native search
+- [ ] Convertire PDF la markdown inainte de a baga in context

memory/kb/youtube/2026-05-02_karpathy-startups-2026.md

@@ -0,0 +1,82 @@
+# Karpathy Just Told Us What Startups To Build For 2026
+
+**Sursa:** https://youtu.be/rsaaVXg28-8?si=y-GTyBmqlWd1cGVb
+**Durata:** 14:07
+**Canal:** Switch Dimension (Rob)
+**Data:** 2026-05-02
+**Tags:** @work @growth
+
+---
+
+## TL;DR
+
+Andrej Karpathy (fost OpenAI, Tesla Autopilot, inventatorul "vibe coding") a dat un talk în care spune că modul în care construim software s-a schimbat fundamental. Dacă tot ce faci e să învelești în cod ceea ce un LLM poate face nativ deja — îți pierzi timpul. Videoul descompune 4 framework-uri pentru ce să construiești în 2026 ca să fii relevant.
+
+---
+
+## Puncte cheie
+
+**1. Software 3.0 — schimbarea de paradigmă**
+- Software 1.0 = cod scris manual (reguli hardcodate)
+- Software 2.0 = rețele neurale antrenate pe date mari
+- Software 3.0 = LLM-ul devine calculatorul programabil; codul tău e promptul, context window-ul e pârghia
+- Dacă ce construiești poate fi înlocuit de un singur prompt multimodal + câteva tool calls → ești "plumbing" care va fi mâncat de următorul release de model
+
+**2. Testul MenuGen**
+- Karpathy a construit anul trecut o aplicație care transforma meniuri în imagini AI ale felurilor de mâncare
+- Azi același lucru se face cu ChatGPT, zero cod
+- **Testul:** Pune-ți app-ul și întreabă: "Poate un singur prompt multimodal + MCP-uri să facă asta?" Dacă DA → pivotează sau omoară proiectul
+
+**3. Vibe coding → Agentic Engineering**
+- Vibe coding a ridicat podeaua — oricine poate construi acum
+- Profesioniștii fac acum "agentic engineering": specs, plans, context management, code review, unit tests, smoke tests, CI blockers
+- Karpathy spune că cei buni la asta merg de 10x mai repede
+- Realitate: 3-4 agenți concurenți e realist, nu 20 cum se laudă pe X
+
+**4. Cele 4 lucruri de construit acum**
+
+1. **Tools care îmbunătățesc înțelegerea, nu doar viteza**
+   - Creează un "strategy agent" cu documente markdown despre domeniul tău/compania ta
+   - Exemplu: folder cu docs de strategie → agent care te ține pe track când vrei să sari la orice oportunitate
+
+2. **Agent-first infrastructure**
+   - Totul de pe internet e construit pentru oameni (UI, dashboards, flows)
+   - Construiește fără UI uman — API-uri clare, llm.txt pe site-uri, MCP-uri
+   - Întreabă: "Ar ști un agent să folosească asta direct, fără traducere umană?"
+
+3. **Verifiable domain capabilities (nișe)**
+   - Marile labs acoperă domeniile mari, nu sub-nișele
+   - Domains cu verifiabilitate ridicată: trading financiar, supply chain, CI/migration agents, data cleaning/labeling
+   - Oportunitate: fine-tuning + reinforcement learning pe nișa ta
+
+4. **Apps care există DOAR datorită Software 3.0**
+   - Nu "spreadsheet mai rapid" sau "UI mai bun pe un workflow existent"
+   - Lucruri complet noi care n-ar fi putut exista fără LLM-uri cu reasoning
+   - Reframarea datelor, compilarea cross-modală, knowledge bases care "gândesc"
+
+---
+
+## Quote-uri
+
+> "If you haven't sat down in the last 60 days and seriously tried to build something end to end with Claude Code or Cursor in agent mode, you are really flying blind."
+
+> "A huge percentage of the apps people are building right now shouldn't exist either. They're basically orchestrating things the model can already do natively."
+
+> "You're skating to where the puck is going to be, not where it is right now."
+
+> "Vibe coding raised the floor. What professionals are doing now is agentic engineering."
+
+---
+
+## Idei aplicabile
+
+- [ ] **Testul MenuGen** — aplică pe proiectele curente: roa2web, chatbot Maria → ce mai are sens?
+- [ ] **Strategy agent** — un folder cu docs de strategie pentru ROA/romfast; agent care dă focus când apar oportunități
+- [ ] **Agent-first în roa2web** — adaugă MCP sau API clar astfel încât un agent să poată interacționa cu ROA fără UI
+- [ ] **Nișa verifiabilă** — ROA operează în domeniu contabil/fiscal (D406, ANAF) = verifiabil, nu acoperit de labs mari → oportunitate fine-tuning
+
+---
+
+## Sursa originală
+
+Karpathy's full talk: menționat în video (link în descriere canal)

memory/kb/youtube/2026-05-02_samsung-ssds-dying.md

@@ -0,0 +1,35 @@
+# Samsung SSDs Are Dying
+
+**URL:** https://youtube.com/shorts/cy_BgJM7R58
+**Data:** 2026-05-02
+**Durată:** 0:52
+**Tags:** @work @tech #ssd #samsung #hardware
+
+---
+
+## TL;DR
+
+Samsung 980 Pro și 990 Pro SSD-urile au un bug de firmware care distruge durata de viață — 50% din HP dispare după o lună. Fix rapid: update firmware la versiunea `5B2QGXA7` prin Samsung Magician.
+
+---
+
+## Puncte cheie
+
+- **Problema:** Firmware defect pe 980 Pro și 990 Pro → SSD-ul își consumă viața de 50x mai repede
+- **Simptome:** SSD rămâne fără spațiu → intră în read-only mode → PC-ul se strică
+- **Cine a identificat:** Puget Systems (producător PC-uri profesionale)
+- **Fix:** Update firmware la `5B2QGXA7` prin **Samsung Magician Software**
+- **Atenție:** Daunele deja produse rămân permanente — fix-ul previne, nu repară
+- **Dacă ai drive <=lună:** încearcă refund
+
+---
+
+## Acțiuni
+
+- [ ] Verifică firmware pe orice Samsung 980/990 Pro în uz: lansează Samsung Magician → dacă nu ești pe `5B2QGXA7`, **actualizează acum**
+
+---
+
+## Transcript
+
+> your ssds are dying it's being found out that Samsung's popular 980 Pro and 990 Pro ssds are experiencing severely shortened lifespans we're talking 50 of their HP disappearing after only a month of use despite them typically lasting years this could lead to the SSD running out of space going into read-only mode and then breaking your entire PC Puget systems an incredible PC Building Company has finally identified the issue and thankfully there's a quick fix for it here's what you need to do you have a two terabyte 980 or 990 Pro check out your firmware version using Samsung's magician software if you're not on firmware version 5b2 qg xa7 then update to that one right away using that same software then your SSD lifespan should resume its normal course but any damage done on the bad firmware is there to stay hopefully you can get a refund if you've experienced this and haven't had the drive for too long because it sucks that

memory/kb/youtube/2026-05-03_ai-coding-dev-team.md

@@ -0,0 +1,58 @@
+# What 6 months of AI coding did to my dev team
+
+**URL:** https://youtu.be/h0hdaHPKDdI?si=_ptaLIMSMrIyXJxe
+**Autor:** Axel Miss (CEO Wu)
+**Durata:** 12:30
+**Data salvare:** 2026-05-03
+**Tags:** @work @growth
+
+---
+
+## TL;DR
+
+CEO-ul unei echipe de 20 de developeri descrie ce s-a schimbat în 6 luni de coding cu AI (Claude Code, Cursor). Concluzia: bottleneck-ul nu mai e scrierea codului, ci specificarea lui. Munca s-a mutat upstream — de la execuție la supraveghere și arhitectură. Seniorii se îneacă în code review, juniorii explodează productiv, iar mid-level-ul e în pericol de relevanță.
+
+---
+
+## Puncte cheie
+
+1. **Bottleneck-ul s-a mutat** — Nu mai e "cine scrie codul", ci "cine scrie spec-ul". AI produce cod rapid, dar fără context → greșeli absurde (sistem de notificări fără rate limiting → 50.000 emailuri în câteva minute).
+
+2. **Specificația e noul produs** — PRD-urile detaliate, state machine-uri, decision tables — ce agile voia să omoare — sunt acum esențiale. AI funcționează excelent cu spec-uri clare. Codul devine dispensabil.
+
+3. **Seniorii devin traffic controllers** — Petrecut majoritate timpului în code review, incapabili să construiască. Juniorii produc cod de 10x mai rapid, dar codul nu se deployează singur.
+
+4. **Juniorii prosperă, mid-level-ul riscă** — Junior fără muscle memory → folosesc AI natural. Mid-level cu ani de "scriu cod într-un fel anume" → greu de reantrenat.
+
+5. **Problema "cheating agent"** — AI scrie cod broken + teste broken care validează codul broken. Trebuie prins înainte de producție.
+
+6. **Cunoașterea instituțională e critică** — Incident la 2 AM: server care cade → AI zice "restart". A fost restartat de 6 ori. Seniorul a văzut în 30s că pool-ul de conexiuni DB era plin din cauza unui cron job. AI nu știa asta. Soluție: "agent subconscious" — knowledge graph cu incidente, edge cases, cunoaștere tribală.
+
+7. **Angry agents** — Agenți antrenați să contrazică, nu să fie de acord. În outage, nu vrei un "yes man".
+
+8. **Stranieri în propriul codebase** — Dacă echipa nu citește cod scris de AI, nu înțelege sistemul. La 3 AM, stai la cod scris de mașină. Soluție: AI să documenteze deciziile arhitecturale → review cu seniorii ÎNAINTE de implementare.
+
+---
+
+## Quote-uri
+
+> "The code started arriving faster than we could process it."
+
+> "The specification became the product. The code is dispensable."
+
+> "Can they write a specification clean enough that an AI can't misinterpret it?"
+
+> "My senior engineers have become traffic controllers — too busy reviewing AI code to build anything themselves."
+
+> "I didn't actually read all the code. I couldn't read all the code. There was too much of it. What do I do now?"
+
+> "Nobody handcodes polygons anymore. We all work in game engines."
+
+---
+
+## Idei acționabile
+
+- [ ] **Spec-uri mai stricte înainte de cod** — înainte de orice feature nou în roa2web, scrie spec clar cu edge cases
+- [ ] **Documentează incidentele** — "ce știa seniorul în cap" când a rezolvat bugul → knowledge base pentru Ralph/AI
+- [ ] **Angry agent mode** — prompt Ralph să contrazică spec-ul înainte de implementare, nu să execute orb
+- [ ] **Review arhitectural al deciziilor AI** — Ralph să documenteze deciziile pe care le ia → Marius le revizuiește periodic

memory/kb/youtube/2026-05-04_oz-pearlman-mentalist-read-people.md

@@ -0,0 +1,81 @@
+# Oz Pearlman (Mentalist): This Small Mistake Makes People Dislike You! They Do This, They're Lying!
+
+**Sursa:** https://youtu.be/4qfxHfBJ3Mw  
+**Canal:** Diary of a CEO (Steven Bartlett)  
+**Durata:** 79 minute  
+**Data:** 2026-05-04  
+**Tags:** @growth @coaching @nlp @communication @sales
+
+---
+
+## TL;DR
+
+Oz Pearlman — mentalist de 30 de ani, fostul analist de pe Wall Street — explică că nu citește mințile, ci oamenii. Succesul lui vine din aceleași principii pe care le poate aplica oricine: fă-l pe celălalt să strălucească, elimină frica de respingere, ia notițe obsesiv, și ascultă mai mult decât vorbești.
+
+---
+
+## Puncte cheie
+
+**1. Nu tu contezi, contează EL**
+Regula #1: nu e despre tine. Niciodată. Fă prezentările orientate pe beneficiile lor, nu pe calitățile tale. Întreabă ce îi împiedică să spună DA, și rezolvă fiecare obiecție pe rând.
+
+**2. Frica de respingere = obstacol #1**
+Majoritatea oamenilor nu își urmăresc obiectivele din frică de eșec. Trucul lui Pearlman: *fast-forward emoțional* — cum te vei simți MÂINE după ce faci lucrul care te sperie? De obicei: nimic. Scala de anxietate cade de la 9 la 2 după ce acționezi.
+
+**3. Listen, Repeat, Reply — sistemul memoriei**
+Inspirat de instrucțiunile de pe șampon (Lather, Rinse, Repeat):
+- **Listen** — 95% din oameni nu ascultă cu adevărat. Taci mintea.
+- **Repeat** — repetă numele de 2-3 ori imediat: "Steve sau Steven?"
+- **Reply** — creează o ancoră: cum se scrie, un compliment vizual, o conexiune cu altcineva
+
+**4. Notițele = cupon fără dată de expirare**
+Pearlman scrie totul imediat după fiecare întâlnire: nume, copii, detalii, ce a funcționat. Informația nu expiră — cu cât o ții mai mult, cu atât impresionezi mai tare când o folosești.
+
+**5. Cel mai interesant om e cel mai interesat**
+Steven Spielberg l-a întrebat pe Pearlman 30 de minute fără să-i lase loc să pună o întrebare. Concluzie: puterea e în a asculta și a pune întrebări neobișnuite — cele care scot omul din autopilot.
+
+**6. Focus-ul tău = focus-ul celorlalți**
+Povestea trucului cu cărțile: nu s-a uitat în sus când a aruncat pachetul, deci nimeni nu a văzut momentul. Oamenii pun atenția exact unde pui tu. Aplică în prezentări, vânzări, coaching.
+
+**7. Hook-ul pozitiv fără posibilitate de refuz**
+La 14 ani, la restaurant: "Ai auzit ce se întâmplă diseară? E ziua ta norocoasă." — nici un DA/NU posibil, dopamine instant. Întrebările deschise cu energie pozitivă generează aproape mereu răspunsuri bune.
+
+**8. Memoria e superputere tocmai pentru că nimeni nu o mai folosește**
+Toți ne bazăm pe telefon. Când cineva îți amintește un detaliu din urmă cu 2 ani, pare magie. Nu e — e pur și simplu atenție și notițe.
+
+**9. Obsesia bate talentul**
+Nu 30 de ani contează, ci pasiunea. Oamenii obsedați de domeniul lor sunt magnetici — îi faci pe ceilalți să se intereseze de subiecte la care nu se gândeau.
+
+**10. Storytelling > trucuri**
+Oamenii nu rețin ce ai făcut, ci povestea pe care o spun altora despre tine. Construiește momentele memorabile, nu impresionante.
+
+---
+
+## Quote-uri
+
+> "It's not about you. It's always about them. That's been the number one secret to my success."
+
+> "The most interesting person in a room tends to be the most interested person in the room."
+
+> "It doesn't matter what I do. It matters what people remember. And what's the story they tell others?"
+
+> "Inspiration, motivation is garbage. I couldn't care less if I've inspired you. I want action."
+
+> "Fear of rejection is the number one factor between failure and success."
+
+> "Information is a coupon with no expiration date. The longer you hold it, the more impressive it is."
+
+> "If you can remember things about that person — not creepy — it's like winning the lottery for them."
+
+> "I stopped thinking about it not working. Those are the entrepreneurs — hyperfixation on making it happen."
+
+---
+
+## Idei acționabile pentru Marius
+
+- [ ] **Prospecție clienți noi:** Aplică "nu e despre tine" — înainte de orice discuție cu un client potențial, scrie 3 lucruri care ÎL deranjează pe el acum. Prezintă soluțiile LUI, nu produsul tău. (@work @sales)
+- [ ] **Fast-forward emoțional:** Când amâni un apel sau o acțiune incomodă (ex: să contactezi un client nou), pune-ți întrebarea: "Cum mă voi simți mâine dimineață dacă îl sun azi vs. dacă nu îl sun?" (@coaching)
+- [ ] **Listen, Repeat, Reply:** La orice întâlnire nouă — repetă numele de 3 ori în primele 30 de secunde. (@growth)
+- [ ] **Notițe după întâlniri:** După orice discuție cu un client sau coleg, notează 2-3 detalii personale. Revizuiește înainte de next meeting. (@work)
+- [ ] **Carte recomandată:** "Read Your Mind" — Oz Pearlman (@growth @nlp)
+- [ ] **Referință:** Conectat cu Atomic Habits (James Clear) — formarea obiceiurilor, nu motivația

memory/kb/youtube/2026-05-04_oz-pearlman-reading-minds-ted.md

@@ -0,0 +1,51 @@
+# The Art of Reading Minds | Oz Pearlman | TED
+
+**Sursă:** https://youtu.be/h3M00JI8Iwo  
+**Data:** 2026-05-04  
+**Durată:** 14:22  
+**Tag-uri:** @growth @coaching #mentalism #comunicare #memorie #npl-adiacent
+
+---
+
+## TL;DR
+
+Oz Pearlman, considerat cel mai mare mentalist din lume, demontează mitul că "citit gânduri" e talent înnăscut. E o abilitate învățată în 30 de ani: observi oamenii, nu gândurile lor. Prezintă două tehnici practice aplicabile imediat: cum să nu uiți niciodată un nume și cum funcționează credința ca profeție auto-împlinită în performanță.
+
+---
+
+## Puncte cheie
+
+1. **Nu citesc mințile, citesc oamenii** — mentalism = observare fină a comportamentului, limbaj corporal, microreacții. Zero puteri supranaturale.
+
+2. **Tehnica numelui: Ascultă → Repetă → Răspunde**
+   - *Ascultă* — golește mintea 2 secunde, nu te gândi la ce vei spune
+   - *Repetă* — folosește numele de 2 ori imediat ("Mă bucur să te cunosc, Ashley")
+   - *Răspunde* — ancorează cu un compliment, ortografie sau conexiune personală
+   - Problema: nu uiți, pur și simplu n-ai știut niciodată — nu ai ascultat
+
+3. **"Iarba e mai verde"** — oamenii își schimbă prima alegere, dar prima impulsie e cea mai autentică. Schimbarea privirii îl trădează.
+
+4. **Credința de neclintit că va funcționa** — principalul factor de succes, pe scenă și în viață. Se auto-împlinește. Nu e aroganță, e mindset.
+
+5. **Infinitul devine gestionabil prin categorii** — orice subiect cu posibilități infinite (persoane celebre) poate fi descompus în categorii: figuri istorice, cântăreți, actori, sportivi, politicieni. Restrângi spațiul de căutare sistematic.
+
+---
+
+## Quote-uri
+
+> "Nu citesc gândurile. Citesc oamenii. Dacă știu cum gândești, știu ce gândești."
+
+> "Nu e o problemă de memorie. Nu ai uitat numele, ci nu l-ai știut niciodată."
+
+> "Credința de neclintit că va funcționa — se auto-împlinește."
+
+> "Ascultă. Repetă. Răspunde." *(tehnica lui din marketing șampon: spumă, clătire, repetați)*
+
+---
+
+## Idei pentru Marius
+
+- **Tehnica ARR (Ascultă-Repetă-Răspunde)** — aplicabil direct în coaching, networking, relații client. Clienții care se simt "auziți" sunt mai loiali.
+- **Credința auto-împlinitoare** — legătură directă cu NLP și coaching: starea interioară precede rezultatul extern. Dacă nu crezi că va merge, nu va merge.
+- **Categorii pentru restrângerea incertitudinii** — util în orice situație cu variabile multe: împarte mai întâi în categorii mari, apoi rafinezi.
+- **Prima impulsie vs. alegerea corectată** — în coaching și NLP, prima reacție/răspuns e adesea mai autentică decât cea "gândită".

memory/kb/youtube/2026-05-05_scott-galloway-ai-wasnt-built-for-you.md

@@ -0,0 +1,84 @@
+# Scott Galloway: AI Wasn't Built For You. The Rich Don't Need You Anymore!
+
+**Sursă:** https://youtu.be/NdU6UdUKaYc  
+**Data:** 2026-05-05  
+**Durată:** 118 min  
+**Tags:** @growth @work
+
+---
+
+## TL;DR
+
+Scott Galloway (profesor NYU, economist) argumentează că AI-ul este în primul rând un instrument de concentrare a avuției, nu unul democratic — percepția pozitivă despre AI corelează direct cu avuția. Catastrofizarea despre locurile de muncă este parțial fundraising deghizat, dar restructurarea pieței muncii este reală. Tech CEO-ii nu au interesele noastre la inimă — îi facem zeități când ar trebui să cerem reglementare. Cea mai importantă abilitate a viitorului nu e coding-ul, ci storytelling-ul combinat cu reziliența la refuz. GLP-1 (ozempic) va crea mai multă valoare decât AI în viziunea lui.
+
+---
+
+## Puncte cheie
+
+- **Brand-ul AI s-a prăbușit în 18 luni.** Percepția pozitivă despre AI corelează strict cu veniturile — singurul cohort pozitiv e cel cu venituri peste $200k. Restul văd factura la curent crescând fără acces la investiții.
+
+- **Catastrofizarea = fundraising deghizat.** Dacă valuările companiilor AI nu se justifică prin creștere de revenue, atunci CEOs trebuie să promită distrugere masivă de locuri de muncă (eficiențe). Ambele nu pot fi adevărate simultan la nivelul promis.
+
+- **Datele contrazic apocalipsa.** Șomajul în SUA e la 4.5%, job listings pentru radiologi și programatori sunt în creștere, iar numărul de noi afaceri per capita s-a dublat în 10 ani. Nu există semnal de „meteor" în piața muncii.
+
+- **AI nu îți ia locul de muncă — o persoană care știe AI îl ia. Și ia 5 locuri, nu unul.** Un singur analist cu 2 agenți AI face munca a 5 analiști. Un EA competent digital înlocuiește 3 din 10. Multiplicatorul e real.
+
+- **Storytelling e abilitatea #1 a viitorului.** Nu coding, nu Mandarina. Capacitatea de a lua date, de a crea un arc narativ și de a-l comunica convingător — prin orice medium. Toți marii CEO sunt în esență storytelleri (Bezos, Jensen Huang, Alex Karp).
+
+- **Reziliența la refuz e abilitatea cea mai subevaluată și cel mai rapid în declin.** Tinerii, în special bărbații, pierd capacitatea de a îndura refuzul din cauza relațiilor frictionless online. 42% din bărbații 18-24 nu au invitat niciodată o femeie la o întâlnire față-în-față. Antreprenorii de succes au în comun confortul cu "nu".
+
+- **Tech CEO-ii nu sunt zei — fac treaba pentru care sunt plătiți.** Sam Altman, Mark Zuckerberg, Dario Amodei urmează același arc: Anakin → Darth Vader. Nu ei sunt vinovați — noi nu avem reglementatori competenți. „Aceste companii nu ne au interesele la inimă. Trebuie să putem avea încredere în oficiali aleși care le reglementează."
+
+- **Billionarii s-au decuplat complet de America reală.** Nu stau la cozi TSA, nu au asigurare medicală proastă, copiii lor merg la școli de $75k/an. Nu mai au niciun interes în bunăstarea societății — ceea ce e profund periculos. Mulți au „go bags" și buncăre în Noua Zeelandă.
+
+- **AI poate fi folosit ca armă economică de China.** Dacă China dumpează modele AI ieftine/gratuite pe piața SUA, companiile mari renunță la licențele de $X milioane cu OpenAI/Anthropic, valuările colapsează. 40% din S&P e legat de pariul pe AI — o corecție acolo = recesiune imediată.
+
+- **GLP-1 > AI în impact real.** Dacă alegi între renunțarea la AI sau la transportul aerian pentru 3 ani, Galloway alege să renunțe la AI. GLP-1 (ozempic) creează mai multă valoare în viețile reale decât modelele de limbaj.
+
+- **Există șanse 1 din 3 că AI nu va concentra valoare ca e-commerce/social media.** Precedente: aviația, PC-urile, vaccinurile — tehnologii semninale care nu au creat companioni triliardari. Modelele AI converg, se open-source-uiesc. Câștigătorul poate fi stakeholder-ul (noi), nu shareholderul.
+
+- **Recesiunile sunt sănătoase pentru tineri cu capital.** 2008 a dat Amazon la $8, Apple la $10, Netflix la $12 — ulterior 20x. Generația actuală nu a trăit o recesiune reală. Salvările constante de pe piață (bailouts) transferă oportunitate de la tineri spre baby boomers.
+
+- **Formula bogăției: lent + disciplinat + diversificat.** Niciun sector specific nu e sigur. Investiție maximă 3% din net worth într-un singur activ. Cel mai mare ROI: investiția în tine însuți și în relații timpurii — ele compoundează.
+
+- **Scopul (purpose) se găsește în lucrurile cu ROI negativ.** Copiii, voluntariatul, cauzele mari — ceva în care dai atât de mult încât nu poți să recuperezi. Acolo e scopul. Nu în lucruri tranzacționale unde vrei să fii pe profit.
+
+---
+
+## Quotes memorabile
+
+> "Your view of AI is directly correlated to your wealth. The only cohort that has a positive rating of AI is people making over $200,000."
+
+> "AI is not going to take your job. Someone who understands AI is going to take your job. But they won't just take one job — they'll take five of those jobs."
+
+> "To say you're not going to learn AI is like being in 1998 and saying 'Well, I don't use PCs.'"
+
+> "The new Jesus Christ of our era are these tech CEOs. And here's what we fail to understand: they do not have our best interests at heart. They are not concerned with our emotional well-being. Their job is to increase earnings per share every day."
+
+> "I think we will never be as prosperous — incredible prosperity, incredible economic growth — and massive loneliness, depression, anxiety, and obesity."
+
+> "The recession for love is grief. I hope my boys feel the same way about me. Nothing went outside. I miss my mom terribly."
+
+> "Nothing's ever as good or as bad as it seems. When you look back on the biggest disappointments, you're not going to be disappointed about the thing that happened — you're going to be disappointed about how upset you were."
+
+---
+
+## Idei de aplicat
+
+- **Two screens rule:** Deschide un al doilea ecran dedicat exclusiv AI. Orice vine digital, testează-l imediat prin LLM. Nu AI fluency abstractă — practică zilnică, concretă.
+
+- **Multiplier mindset:** Dacă poți face munca a 5 oameni cu AI, nu te gândi la eficiență — gândește-te la ce poți construi cu capacitatea eliberată. Marius poate scala Ralph sau alte proiecte fără a angaja.
+
+- **Vinde-te mai scump.** Galloway spune explicit: crește prețul cu 30-50% față de ce ai în cap. Pricing e semnal. Clienții vor negocia în jos, dar nu vor oferi niciodată mai mult.
+
+- **Storytelling > orice skill tehnic.** Capacitatea de a explica ce construiești, de ce contează, și de a convinge — investitori, clienți, parteneri — e mai valoroasă pe termen lung decât orice stack tehnic.
+
+- **Reziliența la "nu" e un mușchi.** Aplică la proiecte supradimensionate, clienți mari, parteneriate ambițioase. Marius antreprenor: trimite propuneri unde te crezi subcalificat. Cel mai rău răspuns e "nu" — ceea ce e OK.
+
+- **Nu pune mai mult de 3% din capital în un singur pariu.** Diversificare extremă, index funds low-cost pentru fondul de bază. Capitalul de "distracție" (30%) pentru Nvidia, cripto, startups — știind că piața te va bate.
+
+- **Recesiunea = oportunitate, nu dezastru.** Dacă vine o corecție în AI (și Galloway o vede probabilă), activele bune devin accesibile. Fii lichid și pregătit, nu defensiv și speriat.
+
+- **Relațiile compoundează mai mult decât banii.** Investiție mică de timp/atenție în oameni la 20-30 de ani → dividende masive la 40-50. Fii generos când nu ai putere — oamenii își amintesc cine i-a ajutat când era greu.
+
+- **Scopul real e asimetric.** Dacă un proiect sau o relație îți oferă mai mult decât dai, nu e scopul tău — e o tranzacție. Scopul apare când dai mai mult decât poți recupera (copii, cauze, echipă).

prompts/planning_agent.md

@@ -25,24 +25,39 @@ dacă scrie EN, mergi EN). Concis: 3-6 propoziții per turn, nu eseuri.
 
 Faza curentă e numele unui skill gstack (`/office-hours`, `/plan-ceo-review`,
 `/plan-eng-review`, `/plan-design-review`). Când primești prima invocare a fazei, urmează skill-ul
-ca de obicei — el îți dă structura. Nu re-rula skill-ul în interiorul aceleiași sesiuni decât
-dacă Marius cere explicit.
+ca de obicei — el îți dă structura.
 
-Fiecare fază rulează într-un **subprocess Claude separat** (fresh `claude -p`). Sesiunea
-precedentă a salvat un artifact pe disc (`~/.gstack/projects/{slug}/...`); citește-l ca să nu îl
-întrebi pe Marius lucruri lămurite deja.
+**INTERZIS** să rulezi `/plan-ceo-review`, `/plan-eng-review` sau `/plan-design-review`
+ca tool-call în interiorul fazei curente. Fiecare fază rulează într-un **subprocess Claude
+separat** (fresh `claude -p`) pe care îl pornește orchestratorul. Dacă te simți „gata" la
+office-hours, nu continua singur cu CEO review — închide turnul cu marker-ul `ready_to_advance`
+și orchestratorul va porni următorul subprocess. Asta e singura cale prin care
+`phases_completed` din `sessions/planning.json` crește și UI-ul îți arată progresul real.
+
+Sesiunea precedentă a salvat un artifact pe disc (`~/.gstack/projects/{slug}/...`); citește-l
+ca să nu îl întrebi pe Marius lucruri lămurite deja.
 
 ## Reguli de output
 
 1. **Întrebări pentru Marius** — pune-i 1–3 întrebări la rând, nu 10. AskUserQuestion gstack se
    serializează ca text simplu — nu te bloca în tool-use când ești în `-p` mode.
-2. **Marker de progres** — când consideri faza completă în mintea ta, închide turnul cu o
-   linie pe ultim rand:
+2. **Marker de progres — OBLIGATORIU pe ultima linie a FIECĂRUI turn**, fără excepție.
+   Două valori posibile:
+   - `PHASE_STATUS: needs_input` — încă mai ai nevoie de informații/clarificări de la Marius
+     în această fază. Default pentru orice turn intermediar.
+   - `PHASE_STATUS: ready_to_advance` — faza e completă în mintea ta, artefactul e scris pe
+     disc, e clar ce urmează. Echo o citește și avansează automat la faza următoare
+     (subprocess proaspăt, fără click suplimentar din partea lui Marius).
+   Marker-ul trebuie să fie **ultima linie** din răspuns, fără text după el. Fără el, sistemul
+   presupune `needs_input` și rămâi blocat în faza curentă.
+
+   Exemplu de tranziție corectă la sfârșit de office-hours:
    ```
+   Am surprins toate aspectele esențiale. Salvez artifact-ul în ~/.gstack/projects/{slug}/
+   user-mariusm-master-office-hours-summary.md și sunt gata pentru CEO review.
+
    PHASE_STATUS: ready_to_advance
    ```
-   Echo (orchestratorul) o citește și îi prezintă lui Marius butonul „Continuă faza".
-   Dacă mai ai nevoie de input, închide cu `PHASE_STATUS: needs_input`.
 3. **Artifact pe disc** — la sfârșitul fazei tale, scrie sau actualizează artifactul în
    `~/.gstack/projects/{slug}/{user}-{phase}-...md` conform convenției skill-ului. Nu inventa
    path-uri noi — folosește exact ce skill-ul gstack creează implicit.

src/planning_session.py

@@ -94,7 +94,7 @@ PHASE_NEEDS_INPUT_MARKER = "PHASE_STATUS: needs_input"
 #       "planning_session_id": "<echo internal uuid>",
 #       "started_at": "...",
 #       "updated_at": "...",
-#       "last_text_excerpt": "...",  # 500 char excerpt for debugging
+#       "last_text_excerpt": "...",  # ≤50K char fallback excerpt; full transcript lives in Claude's session JSONL
 #       "last_subtype": "success" | "error_max_turns" | ...,
 #     }
 #   }
@@ -418,7 +418,7 @@ class PlanningSession:
             "channel_id": self.channel_id,
             "started_at": existing.get("started_at", now),
             "updated_at": now,
-            "last_text_excerpt": (self._last_response or "")[:500],
+            "last_text_excerpt": (self._last_response or "")[:50000],
             "last_subtype": self._last_subtype,
             "total_cost_usd": (
                 float(existing.get("total_cost_usd") or 0.0) + float(cost_usd or 0.0)