@cachly-dev/mcp-server 0.10.48 → 0.10.50

package/.github/workflows/eas-build-android.yml

@@ -0,0 +1,58 @@
+name: EAS Build — TCO Android Preview
+
+on:
+  workflow_dispatch:
+    inputs:
+      message:
+        description: 'Build reason'
+        default: 'manual build'
+
+jobs:
+  build:
+    name: Build Android preview APK
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: apps/travel-chaos-organizer/frontend
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Convert SVG icons to PNG (EAS Build requires PNG)
+        run: |
+          sudo apt-get install -y --no-install-recommends librsvg2-bin
+          rsvg-convert -w 1024 -h 1024 assets/icon.svg        -o assets/icon.png
+          rsvg-convert -w 1024 -h 1024 assets/adaptive-icon.svg -o assets/adaptive-icon.png
+          rsvg-convert -w 2048 -h 2048 assets/splash.svg        -o assets/splash.png
+          echo "Icons converted:"
+          ls -lh assets/*.png
+
+      - name: Setup EAS
+        uses: expo/expo-github-action@v8
+        with:
+          eas-version: latest
+          token: ${{ secrets.EXPO_TOKEN }}
+
+      - name: Create .env with production variables
+        run: |
+          echo "EXPO_PUBLIC_API_URL=${{ secrets.EXPO_PUBLIC_API_URL }}" >> .env
+          echo "EXPO_PUBLIC_KEYCLOAK_URL=${{ secrets.EXPO_PUBLIC_KEYCLOAK_URL }}" >> .env
+          echo "EXPO_PUBLIC_KEYCLOAK_REALM=${{ secrets.EXPO_PUBLIC_KEYCLOAK_REALM || 'travel-chaos' }}" >> .env
+          echo "EXPO_PUBLIC_KEYCLOAK_CLIENT_ID=${{ secrets.EXPO_PUBLIC_KEYCLOAK_CLIENT_ID || 'tco-mobile' }}" >> .env
+
+      - name: Build Android (preview — internal distribution)
+        run: |
+          eas build \
+            --profile preview \
+            --platform android \
+            --non-interactive \
+            --no-wait
+        # --no-wait: EAS build runs in the cloud asynchronously.
+        # Download the APK from expo.dev → your project → Builds when done (~10-15 min).

package/.github/workflows/eas-update.yml

@@ -0,0 +1,55 @@
+name: EAS Update — TCO Production
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'apps/travel-chaos-organizer/frontend/**'
+  workflow_dispatch:
+    inputs:
+      message:
+        description: 'Update message'
+        default: 'OTA update'
+
+jobs:
+  update:
+    name: Publish EAS Update to production
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: apps/travel-chaos-organizer/frontend
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: TypeScript typecheck
+        run: npx tsc --noEmit
+
+      - name: Create .env with production variables
+        run: |
+          echo "EXPO_PUBLIC_API_URL=${{ secrets.EXPO_PUBLIC_API_URL }}" >> .env
+          echo "EXPO_PUBLIC_KEYCLOAK_URL=${{ secrets.EXPO_PUBLIC_KEYCLOAK_URL }}" >> .env
+          echo "EXPO_PUBLIC_KEYCLOAK_REALM=${{ secrets.EXPO_PUBLIC_KEYCLOAK_REALM || 'travel-chaos' }}" >> .env
+          echo "EXPO_PUBLIC_KEYCLOAK_CLIENT_ID=${{ secrets.EXPO_PUBLIC_KEYCLOAK_CLIENT_ID || 'tco-mobile' }}" >> .env
+
+      - name: Publish EAS Update
+        env:
+          EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }}
+        run: |
+          MESSAGE="${{ github.event.inputs.message || github.event.head_commit.message }}"
+          MESSAGE="${MESSAGE:0:100}"
+          # Publish to both channels so preview and production builds both get the update
+          npx eas-cli update \
+            --branch production \
+            --message "$MESSAGE" \
+            --non-interactive
+          npx eas-cli update \
+            --branch preview \
+            --message "$MESSAGE" \
+            --non-interactive

package/BENCH.md

@@ -0,0 +1,80 @@
+# Cachly-Bench — the recall-quality proof
+
+> The STRATEGY.md moat claim is: *Cachly's structured, quality-aware recall beats
+> raw text matching (and a flat-file memory) at surfacing the lesson that actually
+> helps.* A claim without a number is marketing. This is the number.
+
+## Run it
+
+```bash
+npm run bench            # pretty report
+npm run bench -- --json  # machine-readable
+```
+
+The benchmark is also a CI regression guard: `src/__tests__/rerank.test.ts`
+asserts that quality reranking never regresses the headline metrics and that the
+baseline is already strong (so the corpus isn't rigged).
+
+## What it measures
+
+Two rankers are compared over the **same** BM25 candidate set, so the comparison
+isolates *ranking quality*, not retrieval:
+
+| Ranker | What it does | Analogy |
+|---|---|---|
+| `baseline` | raw BM25+ keyword score (`src/search.ts`) | a text-only / flat-file memory |
+| `cachly` | BM25+ then quality-aware rerank (`src/rerank.ts`) | structured, trust-aware recall |
+
+Quality reranking boosts a lesson by its **outcome** (proven success > partial >
+failed attempt), **confidence**, **proven-ness** (`recall_count`, log-saturated)
+and **severity** — clamped so a strong text match is never fully buried, and a
+weak one never catapulted on quality alone.
+
+## The corpus is fair (not rigged)
+
+The fixture corpus (`src/bench/fixtures.ts`) is deliberately and *fairly*
+adversarial: for several queries a **symptom-dense failed attempt** competes with
+the **solution-focused proven success**. This mirrors reality — failed attempts
+repeat the symptom verbatim ("still stuck, still failing"), while the lesson that
+fixed it is written in solution vocabulary. BM25 alone is fooled by the symptom
+density; quality reranking corrects it.
+
+The baseline still scores well (MRR ~85%, Precision@1 75%) — we are not making a
+weak baseline look bad. We are improving an already-good one on the cases that
+matter.
+
+## Current results
+
+```
+  corpus: 15 lessons · queries: 12
+
+  metric         baseline       cachly          lift
+  Precision@1       75.0%  →     83.3%     +11.1%
+  Precision@3       33.3%  →     33.3%      +0.0%
+  Recall@3          95.8%  →     95.8%      +0.0%
+  MRR               84.7%  →     90.3%      +6.6%
+  nDCG@5            87.3%  →     91.7%      +5.0%
+```
+
+**Headline: Precision@1 +11.1%, MRR +6.6%, nDCG@5 +5.0%.**
+
+Interpretation: when the agent asks a question, the *first* result is the proven
+fix 11% more often, and the proven fix sits higher in the list overall. On the
+hardest cases (a failed attempt out-ranking the success on text alone), reranking
+flips the order to the lesson that actually solves the problem.
+
+## Honest limitations (read this)
+
+- **Small corpus.** 15 lessons, 12 queries. This proves the *mechanism* works and
+  guards against regressions. It does **not** yet prove real-world magnitude. The
+  next step (STRATEGY Phase 2) is a larger, externally-sourced corpus and a
+  head-to-head against an actual flat-file memory baseline on real agent traces.
+- **Ranking, not retrieval.** Both rankers see the same BM25 candidates, so this
+  measures the quality layer only. Semantic retrieval (embeddings) is evaluated
+  separately and is not in these numbers.
+- **Labels are ours.** Gold relevance is author-assigned. A credible public
+  benchmark needs third-party labels.
+
+The point of this file is not to claim victory. It is to make the moat
+*measurable* and *defended by CI*, so every future change to recall must move this
+number in the right direction — or it doesn't ship.

package/README.md

@@ -20,10 +20,6 @@
     <img src="https://img.shields.io/badge/GDPR-EU%20servers-green" alt="GDPR: EU servers" />
   </a>
   &nbsp;
-  <a href="https://smithery.ai/server/@cachly-dev/cachly-mcp">
-    <img src="https://smithery.ai/badge/@cachly-dev/cachly-mcp" alt="Smithery" />
-  </a>
-  &nbsp;
   <img src="https://img.shields.io/badge/80%20MCP%20tools-violet" alt="80 MCP tools" />
   &nbsp;
   <img src="https://img.shields.io/badge/License-Apache--2.0-yellow" alt="License: Apache-2.0" />
@@ -166,7 +162,7 @@ npx @cachly-dev/mcp-server@latest learn-git # Auto-learn lessons from recent git
 ```
 
 > **Tip — auto-learn on every merged PR:** run `learn-git` in CI via the
-> [cachly-brain-setup GitHub Action](https://github.com/marketplace/actions/cachly-brain-setup)
+> [cachly-brain-setup GitHub Action](https://github.com/cachly-dev/cachly/tree/main/sdk/github-action)
 > with `mode: learn`. Each merged PR teaches your Brain automatically — no manual calls.
 
 ---
@@ -391,34 +387,10 @@ On the first tool call your AI will prompt you to sign in — takes 10 seconds.
 
 ## 🛠️ Ecosystem
 
-### 🧠 AI Memory & IDE Integration
-
-| | Package / Tool | What it does |
-|---|---|---|
-| 📦 | **[`@cachly-dev/mcp-server`](https://www.npmjs.com/package/@cachly-dev/mcp-server)** | ← you are here — MCP server for Claude Code, Cursor, Copilot & Windsurf |
-| 🔌 | **[VS Code Extension](https://marketplace.visualstudio.com/items?itemName=cachly-dev.cachly-brain)** | Brain status bar · CodeLens lesson hints · ambient auto-learning · Memory Crystals 💎 |
-| 🔌 | **IntelliJ Plugin** *(coming soon)* | Same persistent AI memory for JetBrains IDEs (IDEA, PyCharm, WebStorm, …) |
-| ⚙️ | **[GitHub Action](https://github.com/marketplace/actions/cachly-brain-setup)** | Auto-configure AI Brain for any repo in CI — generates `copilot-instructions.md` & `.mcp.json` |
-
-### 💰 LLM Cost Reduction
-
-| | Package | What it does |
-|---|---|---|
-| 📦 | **[`@cachly-dev/openclaw`](https://www.npmjs.com/package/@cachly-dev/openclaw)** | Cut OpenAI / Anthropic API costs **60–90%** — semantic cache with BM25+ fuzzy matching, no embeddings required |
-
-### 📦 SDK — Managed Cache + AI Memory
-
-| Language | Package | Install |
-|---|---|---|
-| Node.js / TS | [`@cachly-dev/sdk`](https://www.npmjs.com/package/@cachly-dev/sdk) | `npm i @cachly-dev/sdk` |
-| Python | [`cachly`](https://pypi.org/project/cachly/) | `pip install cachly` |
-| Rust | [`cachly`](https://crates.io/crates/cachly) | `cargo add cachly` |
-| Go | [`cachly-dev/cachly-go`](https://pkg.go.dev/github.com/cachly-dev/cachly-go) | `go get github.com/cachly-dev/cachly-go` |
-| .NET / C# | [`Cachly.Client`](https://cachly.dev/docs/api) | `dotnet add package Cachly.Client` |
-| Java | [`dev.cachly:cachly-java`](https://cachly.dev/docs/api) | Maven / Gradle |
-| Kotlin | [`dev.cachly:cachly-kotlin`](https://cachly.dev/docs/api) | Maven / Gradle |
-| Swift | [`Cachly`](https://cachly.dev/docs/api) | Swift Package Manager |
-| PHP | [`cachly-dev/sdk`](https://packagist.org/packages/cachly-dev/sdk) | `composer require cachly-dev/sdk` |
+| Package | What it does |
+|---------|-------------|
+| **[`@cachly-dev/mcp-server`](https://www.npmjs.com/package/@cachly-dev/mcp-server)** | ← you are here |
+| **[`@cachly-dev/openclaw`](https://www.npmjs.com/package/@cachly-dev/openclaw)** | Cut LLM costs 60–90% in JS/TS apps |
 
 ---
 

package/STRATEGY.md

@@ -0,0 +1,218 @@
+# Cachly vs. Anthropic Memory — Ehrliche Standortbestimmung & 10x/100x-Roadmap
+
+> Stand: 29. Mai 2026 · Verfasst als interne, schonungslose Bestandsaufnahme.
+> Ziel: Wo stehen wir wirklich, was ist der Graben den Anthropic uns gräbt, und
+> was braucht es konkret, damit Cachly für die nächsten Jahre 10–100x besser,
+> stabiler, intelligenter und nutzerfreundlicher dasteht.
+
+---
+
+## 0. TL;DR (für die Eiligen)
+
+- **Die Lücke, die wir füllen wollten, schließt Anthropic gerade selbst** — aber
+  nur für den Solo-Claude-Nutzer. Das Memory Tool, Managed-Agents-Memory,
+  Chat-Memory und "Dreaming" decken den **Single-User-, Single-Vendor-Fall**
+  zunehmend gut ab.
+- **Unser echter, verteidigbarer Graben liegt woanders**: *team-/org-weites,
+  strukturiertes, vendor- und tool-unabhängiges Wissen mit Governance.* Genau das
+  kann Anthropic strukturell **nicht** liefern, ohne ihr eigenes Lock-in-Modell zu
+  untergraben.
+- **Brutale Wahrheit**: Heute gewinnen wir diesen Graben *nicht* überzeugend.
+  Onboarding hat zu viel Reibung, die Recall-Qualität ist nicht nachweisbar besser
+  als "Claude liest seine eigenen Files", und wir hatten zuletzt zu viele Bugs für
+  ein Produkt, das gegen ein First-Party-Feature antritt.
+- **Der Weg zu 10x/100x** ist kein Feature-Wettrennen mit Anthropic. Es ist:
+  (1) **Recall-Qualität messbar überlegen machen**, (2) **Onboarding auf
+  Null-Reibung** bringen, (3) **Team-Wissensgraph zum Moat ausbauen**,
+  (4) **vendor-/tool-agnostisch** bleiben, (5) **Stabilität auf First-Party-Niveau**.
+
+---
+
+## 1. Was Anthropic heute hat (der ehrliche Blick auf den Gegner)
+
+| Feature | Was es ist | Reichweite | Schwäche für uns nutzbar? |
+|---|---|---|---|
+| **Memory Tool** (`memory_20250818`) | Client-seitige Datei-Ops im `/memories`-Verzeichnis, 6 Commands (view/create/str_replace/insert/delete/rename) | Nur Anthropic-API, nur Claude-Modelle | **Ja** — unstrukturiert (flache Files), kein semantisches Retrieval, per-Agent |
+| **Managed Agents Memory** (Public Beta, Apr 2026) | Anthropic-gehostete Files, via API/Console exportierbar | Anthropic-Plattform | **Ja** — kein Team-Sharing-Modell, kein Wissensgraph |
+| **Chat Memory** (März 2026) | Auto-Destillation von Chats ~alle 24h in ein Memory-Profil | Consumer (Free/Pro/Max) | **Ja** — Consumer-only, nicht für Dev-Workflows/CI/Teams |
+| **Dreaming** (Research Preview) | Background-Prozess: Muster aus Sessions extrahieren, Memory kuratieren | Claude-intern | ⚠️ **Gefährlich** — das ist konzeptionell *unser* Crystallize/Belief-Update |
+| **Opus 4.8 Context** | 1M Token default, "infinite conversations" via Summarization, Suche über alte Chats | Claude | ⚠️ Reduziert den *Bedarf* an externem Memory für Solo-User |
+
+### Die unbequeme Erkenntnis
+Anthropics Memory ist **gratis, null Setup, first-party, und wird monatlich besser.**
+Für einen einzelnen Entwickler, der ausschließlich Claude nutzt, ist die Frage
+"Warum Cachly statt dem eingebauten Memory?" heute **nicht trivial zu beantworten.**
+
+---
+
+## 2. Wo Cachly strukturell gewinnen kann (der echte Graben)
+
+Diese vier Punkte kann Anthropic nicht ohne Selbst-Sabotage angreifen:
+
+### 2.1 Vendor- & Tool-Unabhängigkeit
+- Anthropic-Memory lebt **in Anthropics Filesystem, gebunden an Claude über die
+  Anthropic-API.** Wechselst du zu GPT, Gemini, einem lokalen Modell oder nutzt
+  Cursor/Windsurf/Zed parallel — **dein Memory ist weg oder fragmentiert.**
+- Cachly spricht **MCP** → funktioniert mit *jedem* MCP-Client und ist
+  modell-agnostisch. **Dein Org-Wissen überlebt jeden Modellwechsel.**
+- *Das ist die Positionierung, die nie veraltet:* "Switzerland für AI-Memory."
+
+### 2.2 Team-/Org-weites Wissen
+- Anthropic-Memory ist **per-User / per-Agent.** Es gibt kein "Kollege A lernt
+  etwas, Kollege B profitiert beim nächsten `session_start`."
+- `team_learn` + geteilte Brain-Instanz ist **genau das** — und es ist der
+  Use-Case mit dem höchsten ökonomischen Wert (verhindert, dass 10 Entwickler
+  denselben Fehler 10x machen).
+
+### 2.3 Strukturiertes, kuratiertes Wissen statt flacher Files
+- Anthropic = Claude liest linear Textdateien.
+- Cachly = strukturierte Lessons (`topic`, `outcome`, `severity`, `tags`,
+  `depends_on`), Contradiction-Detection, Causal Knowledge Graph (CKG),
+  Belief-Update-Engine (BUE). **ABER:** dieser Vorteil ist heute *behauptet, nicht
+  bewiesen.* Siehe §3.
+
+### 2.4 Governance, Compliance, Self-Hosting
+- Self-hosted Valkey, BYOK, Audit-Trails, DSGVO-Löschung, SOC-2-Pfad.
+- Enterprises **dürfen** ihr Wissen oft nicht in Anthropics Managed Memory legen.
+  Das ist ein Verkaufsargument, das mit der Zeit *stärker* wird, nicht schwächer.
+
+---
+
+## 3. Wo wir heute ehrlich schwach sind
+
+Kein Schönreden:
+
+1. **Recall-Qualität ist nicht gemessen.** Wir behaupten "strukturiert > flache
+   Files", haben aber **kein Benchmark**, das zeigt: Cachly-Recall führt zu
+   weniger Wiederholungsfehlern / besseren Antworten als das eingebaute Memory.
+   *Ohne diesen Beweis ist unser Hauptargument Marketing.*
+2. **Onboarding-Reibung.** Anthropic: 0 Setup. Cachly: Instanz provisionieren,
+   Device-Flow, MCP-Config, JWT-Persistenz, Instance-ID. Jede dieser Stufen ist
+   ein Drop-off-Punkt — und mehrere waren zuletzt **kaputt** (JWT nur im RAM,
+   Redis NOAUTH, Provisioning-Timeouts).
+3. **Stabilität.** Wir haben in den letzten Tagen viele kritische Bugs gefunden und
+   gefixt (Telemetrie-Zähler bei 0, NOAUTH, PKCE komplett kaputt, doppelte Drip-
+   Mails, Admin-Bypass). Ein Produkt, das gegen ein First-Party-Feature antritt,
+   **darf solche Bugs nicht haben.** Vertrauen ist hier asymmetrisch.
+4. **Wertnachweis fehlt dem User.** Der Nutzer sieht nicht, *dass* Cachly ihm
+   gerade einen Fehler erspart hat. Anthropics Memory ist unsichtbar-bequem;
+   unseres ist sichtbar-umständlich. Das muss sich umkehren.
+5. **"Dreaming" ist eine direkte Bedrohung** für unser Crystallize/BUE-
+   Alleinstellungsmerkmal. Wenn das Modell selbst Muster extrahiert, müssen wir
+   beim *Team-übergreifenden* und *strukturierten* Teil uneinholbar sein.
+
+---
+
+## 4. Die 10x/100x-Roadmap (konkret, priorisiert)
+
+> Leitsatz: **Wir gewinnen nicht, indem wir Anthropics Memory kopieren. Wir
+> gewinnen, indem wir das werden, was Anthropic strukturell nicht sein darf:
+> der neutrale, team-weite, beweisbar-bessere Wissens-Layer über allen Modellen.**
+
+### Phase 1 — Stabilität & Null-Reibung (die Eintrittskarte) · *0–3 Monate*
+Ohne das ist alles andere wertlos.
+
+- **[10x Stabilität]** Vollständige Test-Suite für die Brain-Tools (Recall, Learn,
+  Dedup, Contradiction). Heute faktisch ungetestet. Ziel: jede Tool-Antwort hat
+  einen Vertragstest.
+- **[10x Onboarding]** "Ein-Befehl-Setup": `npx @cachly-dev/init` → Auto-Provision,
+  Device-Flow, MCP-Config-Write, erster `brain_from_git`-Seed, alles in <60s,
+  idempotent, mit klarem Fortschritt. Jeder bisherige Drop-off-Punkt eliminiert.
+- **[Reibung]** Graceful Degradation: Wenn Redis/Netz weg ist, darf das Tool
+  **nie** den ganzen Agent-Call blockieren. Timeouts + Circuit-Breaker überall.
+- **[Vertrauen]** Self-Healing-Auth: JWT/Instance-ID persistent, automatische
+  Re-Provisionierung bei verlorenem State, kein "0 Recalls weil RAM-only" mehr.
+
+### Phase 2 — Beweisbar bessere Recall-Qualität (der Moat-Beweis) · *3–9 Monate*
+Das ist der Punkt, an dem wir *verdienen*, gegen First-Party anzutreten.
+
+> **Status (begonnen):** Erste Bausteine sind live — `npm run bench`
+> (siehe [BENCH.md](./BENCH.md)) misst den Recall-Lift und ist CI-verteidigt.
+> Aktuelle Zahl: **Precision@1 +11.1 %, MRR +6.6 %, nDCG@5 +5.0 %** gegenüber
+> reinem BM25. Quality-Reranking (`src/rerank.ts`) ist in `smart_recall` verdrahtet,
+> Contradiction-Resolution wird jetzt persistiert. Nächster Schritt: größerer,
+> extern gelabelter Korpus + Head-to-head gegen ein echtes Flat-File-Memory.
+
+- **[✅ erledigt]** **Quality-aware Reranking**: proven success-Lessons ranken über
+  text-ähnlichen Fehlversuchen (`src/rerank.ts`, in `smart_recall` aktiv).
+- **[✅ erledigt]** **Cachly-Bench**: reproduzierbarer Benchmark mit IR-Metriken
+  (Precision@k, Recall@k, MRR, nDCG), als CI-Regressionswächter. Ohne Zahl keine
+  Story — jetzt gibt es eine Zahl, die jede Recall-Änderung verteidigen muss.
+- **[✅ erledigt]** **Contradiction-Resolution persistent**: Widersprüche werden in
+  `cachly:contradictions:{topic}` als auditierbarer Verlauf gespeichert (TTL'd).
+- **[offen — 100x Intelligenz]** Echtes hybrides Retrieval: semantische Embeddings
+  + Reranking + CKG-Traversierung als *eine* gerankte Liste, gegen das eingebaute
+  Memory gemessen.
+- **[offen — Beweis]** Größerer, extern gelabelter Korpus + Head-to-head gegen ein
+  echtes Flat-File-Memory auf realen Agent-Traces (siehe BENCH.md "Limitations").
+- **[offen — Wertsichtbarkeit]** "Brain saved you here"-Signal im Tool-Output +
+  Dashboard-Metrik (Zeitersparnis wird bereits getrackt: `cachly:stats:time_saved_mins`).
+
+### Phase 3 — Team-Wissensgraph als uneinholbarer Moat · *9–18 Monate*
+Hier ist Anthropic strukturell raus.
+
+- **[100x Team]** Org-weiter Wissensgraph: Lessons, Personen, Dateien, Services als
+  Knoten; Recall berücksichtigt *wer* was gelernt hat und *wo* es relevant ist.
+- **[Virality]** Jeder gelöste Fehler eines Entwicklers wird automatisch zur
+  Org-Lesson — mit Attribution. `team_learn` als Default, nicht als Opt-in.
+- **[Governance]** Rollen, Sichtbarkeits-Scopes, Audit-Trails, "Wissens-Reviews"
+  (ein Senior bestätigt eine Lesson → höheres Vertrauen im Recall-Ranking).
+- **[Enterprise]** Self-Hosted-Tier mit SOC-2/ISO, BYOK by default, Daten bleiben
+  im Kunden-VPC. Das ist der Umsatz, den Anthropic-Memory nicht abgreifen kann.
+
+### Phase 4 — Der neutrale Layer über allen Modellen · *18+ Monate*
+- **[100x Reichweite]** First-class-Support für jeden großen MCP-Client und jedes
+  Modell. Cachly = "bring your own model, keep your brain."
+- **[Ökosystem]** Öffentliche/teilbare Brains (kuratierte Domänen-Wissensbasen:
+  "React-Best-Practices-Brain", "Kubernetes-Incident-Brain"), als Marktplatz.
+- **[Moat-Vertiefung]** Je mehr Org-Wissen akkumuliert, desto höher die
+  Wechselkosten *weg* von Cachly — aber **null** Lock-in beim *Modell*. Das ist
+  die einzige gesunde Form von Lock-in.
+
+---
+
+## 5. Was wir explizit NICHT tun sollten
+
+- **Nicht** versuchen, Anthropics Single-User-Memory zu schlagen. Das verlieren wir.
+  Unser Nutzer ist das **Team** und die **Org**, nicht der Solo-Hobbyist.
+- **Nicht** Feature-für-Feature mit "Dreaming" konkurrieren. Stattdessen den
+  *strukturierten, geteilten, beweisbar-besseren* Teil besitzen.
+- **Nicht** weiter Features stapeln (wir haben ~89 Tools), solange Recall-Qualität
+  und Stabilität nicht bewiesen sind. **Tiefe vor Breite.**
+- **Nicht** vendor-Lock-in beim Modell aufbauen — das ist unser einziger
+  glaubwürdiger Vorteil gegenüber First-Party.
+
+---
+
+## 6. Die drei Metriken, die alles entscheiden
+
+Wenn wir nur drei Zahlen tracken dürften:
+
+1. **Time-to-first-recall** (Onboarding-Reibung): vom `npx`-Befehl bis zum ersten
+   erfolgreichen, wertvollen Recall. Ziel: <2 Minuten.
+2. **Recall-Lift** (Moat-Beweis): % weniger Wiederholungsfehler / schnellere
+   Lösung *mit* Cachly vs. ohne, gemessen über Cachly-Bench. Ziel: messbar >0,
+   dann skalieren.
+3. **Team-Knowledge-Reuse** (Virality/Moat): wie oft wird die Lesson eines
+   Entwicklers von *einem anderen* erfolgreich recallt. Das ist der Wert, den nur
+   wir liefern.
+
+---
+
+## 7. Fazit (schonungslos)
+
+Anthropic hat die **Single-User-Memory-Lücke** weitgehend geschlossen. Hätten wir
+nur darauf gewettet, wären wir in Schwierigkeiten.
+
+Aber die **eigentlich wertvolle Lücke** — *team-weites, strukturiertes,
+vendor-neutrales, governance-fähiges Wissen mit beweisbarem Recall-Vorteil* — ist
+**offen, und Anthropic kann sie aus strukturellen Gründen nicht schließen.**
+
+Heute besetzen wir diese Lücke **noch nicht überzeugend**: zu viel Reibung, zu
+wenig Beweis, zu viele Bugs. Der Weg zu 10x/100x ist deshalb unspektakulär und
+unerbittlich:
+
+> **Erst stabil & reibungslos. Dann beweisbar schlauer. Dann team-weit
+> uneinholbar. Immer modell-neutral.**
+
+In dieser Reihenfolge. Nicht andersrum.

package/apps/travel-chaos-organizer/.env.example

@@ -0,0 +1,49 @@
+# Travel Chaos Organizer — Environment Variables
+# Copy to .env and fill in your values
+
+# App
+DEBUG=false
+UPLOAD_DIR=/data/uploads
+
+# Database (overridden by docker-compose for containerized runs)
+DATABASE_URL=postgresql+asyncpg://tco:tco@localhost:5432/tco
+
+# Keycloak
+KEYCLOAK_URL=http://localhost:8080
+KEYCLOAK_REALM=travel-chaos
+KEYCLOAK_CLIENT_ID=tco-backend
+
+# Ollama — point to your self-hosted instance
+OLLAMA_URL=http://your-server:11434
+OLLAMA_MODEL=llama3.2-vision
+OLLAMA_TIMEOUT=120
+
+# Cachly Redis — caches Ollama parse results to avoid duplicate AI calls.
+# docker-compose sets this automatically (local Redis).
+# In production, replace with your Cachly instance URL:
+#   cachly.dev → Instances → Connection String
+# Same document uploaded twice? Instant response from cache, no second AI call.
+CACHLY_REDIS_URL=redis://localhost:6379/0
+# CACHLY_REDIS_URL=redis://:<password>@<host>.cachly.dev:6380/0
+
+# Telegram Notifier (optional) — get token from @BotFather
+# TELEGRAM_BOT_TOKEN=...
+# TCO_TELEGRAM_CHAT_ID=...   # chat or channel ID for TCO events
+
+# Email — Resend (optional, https://resend.com)
+# RESEND_API_KEY=re_...
+# RESEND_FROM=noreply@yourdomain.com
+
+# Admin dashboard (change before going live!)
+ADMIN_USER=admin
+ADMIN_PASSWORD=changeme
+
+# CORS — comma-separated origins, or * for all
+CORS_ORIGINS=*
+
+# Stripe
+# STRIPE_SECRET_KEY=sk_live_...
+# STRIPE_WEBHOOK_SECRET=whsec_...
+# STRIPE_PRO_PRICE_ID=price_...
+STRIPE_SUCCESS_URL=https://YOUR_DOMAIN/upgrade/success
+STRIPE_CANCEL_URL=https://YOUR_DOMAIN/upgrade/cancel