@kurtel/cli 0.1.8 → 0.1.12

package/dist/commands/hook.js

@@ -0,0 +1,138 @@
+import { repoRoot, repoFullName, loadIndex, loadMemoryCache, memoryEnabled, loadMemoryState, saveMemoryState, queueTelemetry, } from "../memory/store.js";
+import { compileCapsule, compileZoneCapsule, findSimilarRoutes } from "../memory/capsule.js";
+import { syncInBackground } from "../memory/sync.js";
+function readStdin() {
+    return new Promise((resolve) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (c) => (data += c));
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", () => resolve(data));
+        // garde-fou: si rien n'arrive, on rend la main vite
+        setTimeout(() => resolve(data), 2000).unref?.();
+    });
+}
+function emitContext(event, context) {
+    process.stdout.write(JSON.stringify({
+        hookSpecificOutput: { hookEventName: event, additionalContext: context },
+    }));
+}
+export async function hookCommand(event) {
+    try {
+        const raw = await readStdin();
+        let input = {};
+        try {
+            input = raw ? JSON.parse(raw) : {};
+        }
+        catch { /* stdin non-JSON */ }
+        const root = repoRoot(input.cwd ?? process.cwd());
+        if (!memoryEnabled(root))
+            return; // off = silence total, coût zéro
+        switch (event) {
+            case "session-start": return onSessionStart(root, input);
+            case "user-prompt-submit": return onPrompt(root, input);
+            case "post-tool-use": return onPostToolUse(root, input);
+            case "session-end": return onSessionEnd(root, input);
+            default: return;
+        }
+    }
+    catch {
+        /* jamais d'erreur visible: un hook cassé est pire que pas de hook */
+    }
+    finally {
+        process.exitCode = 0;
+    }
+}
+// ── SessionStart: lancer le sync en arrière-plan + une ligne d'état ─────────
+function onSessionStart(root, input) {
+    syncInBackground(root); // pull patterns + flush télémétrie, détaché
+    const index = loadIndex(root);
+    const cache = loadMemoryCache(root);
+    if (!index && !cache.patterns.length)
+        return; // rien à dire → rien dit
+    const bits = [];
+    if (index)
+        bits.push(`codebase index: ${index.files_indexed} files, ${index.routes.length} routes (commit ${index.commit.slice(0, 8)})`);
+    if (cache.patterns.length)
+        bits.push(`${cache.patterns.length} team patterns loaded`);
+    emitContext("SessionStart", `[Kurtel memory active — ${bits.join(", ")}. Relevant context will be injected per task.]`);
+}
+// ── UserPromptSubmit: LA capsule — intention → zones → patterns ─────────────
+function onPrompt(root, input) {
+    const prompt = input.prompt ?? "";
+    if (prompt.length < 8 || prompt.startsWith("/"))
+        return; // slash commands & micro-prompts: silence
+    const index = loadIndex(root);
+    const cache = loadMemoryCache(root);
+    const capsule = compileCapsule(index, cache.patterns, prompt);
+    if (!capsule)
+        return;
+    emitContext("UserPromptSubmit", capsule.text);
+    // mémorise les zones couvertes (pour ne pas répéter au PostToolUse)
+    const sid = input.session_id ?? "unknown";
+    const state = loadMemoryState(root);
+    state.session_zones[sid] = [...new Set([...(state.session_zones[sid] ?? []), ...capsule.zones])];
+    saveMemoryState(root, state);
+    if (capsule.injectedPatternIds.length) {
+        queueTelemetry(root, {
+            ts: new Date().toISOString(),
+            session_id: sid,
+            repo: repoFullName(root),
+            kind: "patterns_injected",
+            pattern_ids: capsule.injectedPatternIds,
+        });
+    }
+}
+// ── PostToolUse: dérive d'intention + anti-duplication de routes ────────────
+const ROUTE_WRITE = /\.(get|post|put|patch|delete)\s*\(\s*["'`]([^"'`]+)["'`]|@(?:Get|Post|Put|Patch|Delete)\s*\(\s*["'`]([^"'`]+)["'`]|@\w+\.(?:get|post|put|patch|delete|route)\s*\(\s*["']([^"']+)["']/;
+function onPostToolUse(root, input) {
+    if (!["Edit", "Write", "MultiEdit"].includes(input.tool_name ?? ""))
+        return;
+    const ti = input.tool_input ?? {};
+    const filePathRaw = (ti.file_path ?? ti.path ?? "");
+    if (!filePathRaw)
+        return;
+    const filePath = filePathRaw.replace(/\\/g, "/").replace(root.replace(/\\/g, "/") + "/", "");
+    const index = loadIndex(root);
+    const cache = loadMemoryCache(root);
+    const sid = input.session_id ?? "unknown";
+    const state = loadMemoryState(root);
+    const seen = new Set(state.session_zones[sid] ?? []);
+    const messages = [];
+    // 1. Anti-duplication: l'agent vient-il d'écrire une route qui existe déjà ?
+    const written = (ti.new_string ?? ti.content ?? "");
+    const rm = written.match(ROUTE_WRITE);
+    if (rm && index) {
+        const newPath = rm[2] ?? rm[3] ?? rm[4] ?? "";
+        const similar = newPath ? findSimilarRoutes(index, newPath).filter((r) => r.file !== filePath) : [];
+        if (similar.length) {
+            messages.push(`[Kurtel duplicate-route check] The route you just wrote ("${newPath}") looks similar to existing routes:\n` +
+                similar.map((r) => `- ${r.method} ${r.path} → ${r.file}:${r.line}`).join("\n") +
+                `\nVerify you are not re-implementing existing work; prefer extending the existing handler.`);
+            queueTelemetry(root, {
+                ts: new Date().toISOString(), session_id: sid, repo: repoFullName(root),
+                kind: "duplicate_flagged", detail: newPath,
+            });
+        }
+    }
+    // 2. Dérive d'intention: nouvelle zone du graphe → micro-capsule de zone.
+    const zone = filePath.includes("/") ? filePath.split("/").slice(0, 2).join("/") : filePath;
+    if (!seen.has(zone)) {
+        const zc = compileZoneCapsule(index, cache.patterns, filePath);
+        if (zc) {
+            messages.push(zc.text);
+            queueTelemetry(root, {
+                ts: new Date().toISOString(), session_id: sid, repo: repoFullName(root),
+                kind: "zone_entered", detail: zone, pattern_ids: zc.injectedPatternIds,
+            });
+        }
+        state.session_zones[sid] = [...seen, zone];
+        saveMemoryState(root, state);
+    }
+    if (messages.length)
+        emitContext("PostToolUse", messages.join("\n\n"));
+}
+// ── SessionEnd / Stop: flush télémétrie en arrière-plan ─────────────────────
+function onSessionEnd(root, _input) {
+    syncInBackground(root);
+}

package/dist/commands/installClaudeCode.js

@@ -0,0 +1,158 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { c, symbols } from "../ui/colors.js";
+import { loadConfig } from "../lib/config.js";
+import { repoRoot } from "../memory/store.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// `kurtel install claude-code`
+//   1. Slash commands → .claude/commands/kurtel/*.md  (/kurtel:onboard, etc.)
+//   2. Hooks → .claude/settings.json (merge JSON structuré, idempotent —
+//      la leçon Graphify: jamais de manipulation de chaîne sur les settings)
+//   3. Vérifie le login; réutilise le token du CLI (zéro re-auth)
+// `kurtel uninstall claude-code` retire proprement nos entrées, rien d'autre.
+// ─────────────────────────────────────────────────────────────────────────────
+const KURTEL_HOOK_MARKER = "kurtel hook"; // identifie NOS hooks dans settings.json
+const HOOK_EVENTS = [
+    { event: "SessionStart", sub: "session-start" },
+    { event: "UserPromptSubmit", sub: "user-prompt-submit" },
+    { event: "PostToolUse", sub: "post-tool-use" },
+    { event: "SessionEnd", sub: "session-end" },
+];
+// ── Slash commands (markdown, format Claude Code custom commands) ───────────
+const SLASH_COMMANDS = {
+    "onboard.md": `---
+description: Index this codebase and activate Kurtel memory (architecture audit + route inventory)
+allowed-tools: Bash(kurtel onboard:*), Read
+---
+Run \`kurtel onboard --json\` with the Bash tool, then:
+1. Parse the JSON output.
+2. Present the architecture snapshot to the user: domains, god nodes (with edge counts — explain these are high-coupling hotspots), and the number of inventoried routes.
+3. Tell them the full report is at the path in \`report_path\` and that Kurtel memory is now active: relevant context (existing routes, team conventions) will be injected automatically per task.
+4. If \`uploaded\` is false, mention that cloud sync failed and they can retry with \`kurtel memory sync\` (memory still works locally).
+Do not re-run indexing if the command fails twice; show the error instead.
+`,
+    "memory.md": `---
+description: Toggle or inspect Kurtel memory (on / off / status / sync / patterns)
+allowed-tools: Bash(kurtel memory:*)
+---
+The user said: "$ARGUMENTS"
+- If it contains "off" or "disable" → run \`kurtel memory off\`
+- If it contains "on" or "enable" → run \`kurtel memory on\`
+- If it contains "sync" → run \`kurtel memory sync\`
+- If it contains "pattern" → run \`kurtel memory patterns --json\` and present the patterns as a readable list (rule, confidence, zones, evidence count), sorted by confidence
+- Otherwise → run \`kurtel memory status --json\` and present a one-line summary
+Relay the result conversationally. Never paste raw JSON to the user.
+`,
+    "status.md": `---
+description: Show Kurtel memory status for this repo
+allowed-tools: Bash(kurtel memory status:*)
+---
+Run \`kurtel memory status --json\` and summarize in 2-3 lines: memory active or not, index freshness (suggest \`/kurtel:onboard\` if none), number of team patterns loaded and last sync time.
+`,
+};
+function isKurtelEntry(h) {
+    return typeof h.command === "string" && h.command.includes(KURTEL_HOOK_MARKER);
+}
+function mergeHooks(settings) {
+    const hooks = settings.hooks ?? {};
+    for (const { event, sub } of HOOK_EVENTS) {
+        const matchers = hooks[event] ?? [];
+        // retirer toute ancienne entrée kurtel (idempotence), sans toucher au reste
+        for (const m of matchers)
+            m.hooks = m.hooks.filter((h) => !isKurtelEntry(h));
+        const cleaned = matchers.filter((m) => m.hooks.length > 0);
+        const entry = { type: "command", command: `kurtel hook ${sub}`, timeout: 10 };
+        if (event === "PostToolUse") {
+            cleaned.push({ matcher: "Edit|Write|MultiEdit", hooks: [entry] });
+        }
+        else {
+            cleaned.push({ hooks: [entry] });
+        }
+        hooks[event] = cleaned;
+    }
+    settings.hooks = hooks;
+    return settings;
+}
+function removeHooks(settings) {
+    if (!settings.hooks)
+        return settings;
+    for (const event of Object.keys(settings.hooks)) {
+        const matchers = settings.hooks[event]
+            .map((m) => ({ ...m, hooks: m.hooks.filter((h) => !isKurtelEntry(h)) }))
+            .filter((m) => m.hooks.length > 0);
+        if (matchers.length)
+            settings.hooks[event] = matchers;
+        else
+            delete settings.hooks[event];
+    }
+    if (!Object.keys(settings.hooks).length)
+        delete settings.hooks;
+    return settings;
+}
+function readSettings(file) {
+    try {
+        if (!existsSync(file))
+            return {};
+        return JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch (e) {
+        throw new Error(`.claude/settings.json exists but is not valid JSON — fix it first (${e instanceof Error ? e.message : e}).`);
+    }
+}
+// ── Commandes ───────────────────────────────────────────────────────────────
+export async function installClaudeCodeCommand() {
+    const root = repoRoot();
+    const claudeDir = join(root, ".claude");
+    const cmdDir = join(claudeDir, "commands", "kurtel");
+    const settingsFile = join(claudeDir, "settings.json");
+    console.log("");
+    // 1. Login check (réutilise le token CLI — pas de re-auth).
+    const config = loadConfig();
+    if (config.loggedIn && config.token) {
+        console.log(`${symbols.check} Using your Kurtel session ${c.dim(`(${config.account ?? "account"})`)}`);
+    }
+    else {
+        console.log(`${c.yellow(symbols.warn)} ${c.dim("Not signed in — memory will work locally; run")} ${c.indigo("kurtel login")} ${c.dim("to sync patterns.")}`);
+    }
+    // 2. Slash commands.
+    if (!existsSync(cmdDir))
+        mkdirSync(cmdDir, { recursive: true });
+    for (const [name, content] of Object.entries(SLASH_COMMANDS)) {
+        writeFileSync(join(cmdDir, name), content, "utf8");
+    }
+    console.log(`${symbols.check} Slash commands installed: ${c.indigo("/kurtel:onboard")}, ${c.indigo("/kurtel:memory")}, ${c.indigo("/kurtel:status")}`);
+    // 3. Hooks (merge structuré, idempotent).
+    let settings;
+    try {
+        settings = readSettings(settingsFile);
+    }
+    catch (e) {
+        console.log(`${c.red(symbols.cross)} ${e instanceof Error ? e.message : String(e)}`);
+        process.exitCode = 1;
+        return;
+    }
+    settings = mergeHooks(settings);
+    writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + "\n", "utf8");
+    console.log(`${symbols.check} Hooks wired into ${c.indigo(".claude/settings.json")} ${c.dim("(SessionStart, UserPromptSubmit, PostToolUse, SessionEnd)")}`);
+    console.log("");
+    console.log(`${c.dim("Next: open Claude Code in this repo and run")} ${c.indigo("/kurtel:onboard")} ${c.dim("to index the codebase.")}`);
+    console.log(`${c.dim("Memory is")} ${c.indigo("on")} ${c.dim("by default — toggle with")} ${c.indigo("/kurtel:memory off")}${c.dim(".")}`);
+    console.log("");
+}
+export async function uninstallClaudeCodeCommand() {
+    const root = repoRoot();
+    const settingsFile = join(root, ".claude", "settings.json");
+    if (existsSync(settingsFile)) {
+        try {
+            const settings = removeHooks(readSettings(settingsFile));
+            writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + "\n", "utf8");
+            console.log(`${symbols.check} Kurtel hooks removed from .claude/settings.json ${c.dim("(other hooks untouched)")}`);
+        }
+        catch (e) {
+            console.log(`${c.red(symbols.cross)} ${e instanceof Error ? e.message : String(e)}`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    console.log(`${c.dim("You can delete")} ${c.indigo(".claude/commands/kurtel/")} ${c.dim("to remove the slash commands.")}`);
+}

package/dist/commands/memory.js

@@ -0,0 +1,89 @@
+import { c, symbols } from "../ui/colors.js";
+import { Spinner } from "../ui/spinner.js";
+import { repoRoot, loadIndex, loadMemoryCache, memoryEnabled, setMemoryEnabled, } from "../memory/store.js";
+import { syncNow } from "../memory/sync.js";
+function ago(iso) {
+    if (!iso)
+        return "never";
+    const m = Math.floor((Date.now() - new Date(iso).getTime()) / 60000);
+    if (m < 1)
+        return "just now";
+    if (m < 60)
+        return `${m}m ago`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ago`;
+    return `${Math.floor(h / 24)}d ago`;
+}
+export async function memoryCommand(action, opts = {}) {
+    const root = repoRoot();
+    switch (action) {
+        case "on":
+            setMemoryEnabled(root, true);
+            console.log(`${symbols.check} Kurtel memory ${c.indigo("enabled")} for this repo.`);
+            return;
+        case "off":
+            setMemoryEnabled(root, false);
+            console.log(`${symbols.check} Kurtel memory ${c.yellow("disabled")} for this repo ${c.dim("(hooks stay installed, injection is skipped)")}.`);
+            return;
+        case "sync": {
+            const spin = opts.quiet ? null : new Spinner("Syncing memory…").start();
+            const res = await syncNow(root);
+            spin?.succeed(`Synced · ${res.pulled} patterns pulled · ${res.flushed} telemetry events flushed`);
+            return;
+        }
+        case "patterns": {
+            const cache = loadMemoryCache(root);
+            if (opts.json) {
+                process.stdout.write(JSON.stringify(cache.patterns));
+                return;
+            }
+            if (!cache.patterns.length) {
+                console.log(c.dim("No patterns yet. They are learned from merged PRs and pulled with `kurtel memory sync`."));
+                return;
+            }
+            console.log("");
+            for (const p of [...cache.patterns].sort((a, b) => b.score - a.score)) {
+                const bar = "█".repeat(Math.round(p.score * 10)).padEnd(10, "░");
+                const zones = p.zones.length ? p.zones.join(", ") : "global";
+                console.log(`${c.indigo(bar)} ${c.dim(String(Math.round(p.score * 100)).padStart(3) + "%")} ${p.pinned ? c.yellow("★ ") : "  "}${c.white(p.rule)}`);
+                console.log(`             ${c.gray("zones")} ${c.dim(zones)} ${c.gray("· evidence")} ${c.dim(String(p.evidence.length) + " PRs")}`);
+            }
+            console.log("");
+            return;
+        }
+        case undefined:
+        case "status": {
+            const enabled = memoryEnabled(root);
+            const index = loadIndex(root);
+            const cache = loadMemoryCache(root);
+            if (opts.json) {
+                process.stdout.write(JSON.stringify({
+                    enabled,
+                    index: index ? { files: index.files_indexed, routes: index.routes.length, commit: index.commit, generated_at: index.generated_at } : null,
+                    patterns: cache.patterns.length,
+                    synced_at: cache.patterns_synced_at,
+                    pending_telemetry: cache.pending_telemetry.length,
+                }));
+                return;
+            }
+            console.log("");
+            console.log(`${c.gray("memory")}    ${enabled ? c.indigo("● active") : c.yellow("○ disabled")}`);
+            if (index) {
+                console.log(`${c.gray("index")}     ${c.white(`${index.files_indexed} files · ${index.routes.length} routes`)} ${c.dim(`(${ago(index.generated_at)}, commit ${index.commit.slice(0, 8)})`)}`);
+            }
+            else {
+                console.log(`${c.gray("index")}     ${c.dim("none — run `kurtel onboard`")}`);
+            }
+            console.log(`${c.gray("patterns")}  ${c.white(String(cache.patterns.length))} ${c.dim(`(synced ${ago(cache.patterns_synced_at)})`)}`);
+            if (cache.pending_telemetry.length) {
+                console.log(`${c.gray("pending")}   ${c.dim(`${cache.pending_telemetry.length} telemetry events (flushed on next sync)`)}`);
+            }
+            console.log("");
+            return;
+        }
+        default:
+            console.log(`${c.red(symbols.cross)} Unknown action ${c.white(action)}. Try ${c.indigo("status")}, ${c.indigo("on")}, ${c.indigo("off")}, ${c.indigo("sync")}, or ${c.indigo("patterns")}.`);
+            process.exitCode = 1;
+    }
+}

package/dist/commands/onboard.js

@@ -0,0 +1,72 @@
+import { writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { c, symbols } from "../ui/colors.js";
+import { Spinner } from "../ui/spinner.js";
+import { buildIndex, renderReport } from "../memory/indexer.js";
+import { repoRoot, saveIndex, reportPath, loadMemoryCache } from "../memory/store.js";
+import { syncIndexUp, syncNow } from "../memory/sync.js";
+export async function onboardCommand(opts = {}) {
+    const root = repoRoot();
+    // 1. Index structurel — local, déterministe, 0 token.
+    const spin = opts.json ? null : new Spinner("Indexing codebase (local, deterministic)…").start();
+    const index = buildIndex(root, (n) => {
+        spin?.update(`Indexing codebase… ${n} files`);
+    });
+    saveIndex(root, index);
+    spin?.succeed(`Indexed ${index.files_indexed} files · ${index.routes.length} routes · ${index.god_nodes.length} god nodes`);
+    // 2. Rapport d'audit — le livrable du jour 0.
+    const report = renderReport(index);
+    const rp = reportPath(root);
+    const dir = join(root, ".kurtel");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(rp, report, "utf8");
+    // 3. Sync: pull des patterns + push du digest pour l'app web.
+    let uploaded = false;
+    let patterns = 0;
+    if (!opts.local) {
+        const spin2 = opts.json ? null : new Spinner("Syncing memory with Kurtel cloud…").start();
+        uploaded = await syncIndexUp(root);
+        try {
+            const r = await syncNow(root);
+            patterns = loadMemoryCache(root).patterns.length;
+            void r;
+        }
+        catch { /* offline ok */ }
+        if (spin2) {
+            if (uploaded)
+                spin2.succeed(`Memory synced · ${patterns} team patterns pulled`);
+            else
+                spin2.fail("Cloud sync failed (offline or not signed in) — memory works locally; run `kurtel memory sync` later.");
+        }
+    }
+    if (opts.json) {
+        // Sortie machine pour le slash command /kurtel:onboard — l'agent lit ce JSON
+        // et présente le rapport à l'utilisateur dans la session.
+        process.stdout.write(JSON.stringify({
+            ok: true,
+            repo: index.repo,
+            files_indexed: index.files_indexed,
+            routes: index.routes.length,
+            god_nodes: index.god_nodes,
+            domains: index.domains.slice(0, 10),
+            report_path: rp,
+            uploaded,
+            patterns_loaded: patterns,
+        }));
+        return;
+    }
+    // Affichage humain
+    console.log("");
+    console.log(`${c.indigoBold("Architecture snapshot")}`);
+    console.log(`${c.gray("repo")}      ${c.white(index.repo)}`);
+    console.log(`${c.gray("domains")}   ${c.white(index.domains.slice(0, 6).map((d) => d.name).join(", "))}`);
+    if (index.god_nodes.length) {
+        console.log(`${c.gray("hotspots")}  ${index.god_nodes.slice(0, 3).map((g) => `${c.indigo(g.id)} ${c.dim(`(${g.degree} edges)`)}`).join("  ")}`);
+    }
+    console.log(`${c.gray("routes")}    ${c.white(String(index.routes.length))} ${c.dim("inventoried — duplicates will be flagged")}`);
+    console.log("");
+    console.log(`${symbols.check} Full report: ${c.indigo(rp)}`);
+    console.log(`${c.dim("Memory is now")} ${c.indigo("active")}${c.dim(" — context is injected per task in Claude Code.")}`);
+    console.log("");
+}

package/dist/index.js

@@ -11,6 +11,10 @@ import { runsCommand } from "./commands/runs.js";
 import { logsCommand, statusCommand, stopCommand } from "./commands/runtime.js";
 import { configCommand } from "./commands/config.js";
 import { initCommand, doctorCommand } from "./commands/project.js";
+import { onboardCommand } from "./commands/onboard.js";
+import { memoryCommand } from "./commands/memory.js";
+import { installClaudeCodeCommand, uninstallClaudeCodeCommand } from "./commands/installClaudeCode.js";
+import { hookCommand } from "./commands/hook.js";
 const program = new Command();
 program
     .name("kurtel")
@@ -86,6 +90,46 @@ program
     .command("doctor")
     .description("Check your environment")
     .action(() => doctorCommand());
+// ── Memory & Claude Code integration ─────────────────────────────────────────
+program
+    .command("install")
+    .description("Install a Kurtel integration (claude-code)")
+    .argument("<target>", "Integration target: claude-code")
+    .action(async (target) => {
+    if (target === "claude-code")
+        return installClaudeCodeCommand();
+    console.log(`${c.red(symbols.cross)} Unknown target ${c.white(target)}. Try ${c.indigo("claude-code")}.`);
+    process.exitCode = 1;
+});
+program
+    .command("uninstall")
+    .description("Remove a Kurtel integration (claude-code)")
+    .argument("<target>", "Integration target: claude-code")
+    .action(async (target) => {
+    if (target === "claude-code")
+        return uninstallClaudeCodeCommand();
+    console.log(`${c.red(symbols.cross)} Unknown target ${c.white(target)}.`);
+    process.exitCode = 1;
+});
+program
+    .command("onboard")
+    .alias("setup")
+    .description("Index this codebase and activate Kurtel memory")
+    .option("--json", "Machine-readable output (used by /kurtel:onboard)", false)
+    .option("--local", "Skip cloud upload — index stays on disk", false)
+    .action(async (opts) => onboardCommand(opts));
+program
+    .command("memory")
+    .description("Inspect or toggle Kurtel memory (status | on | off | sync | patterns)")
+    .argument("[action]", "status | on | off | sync | patterns", "status")
+    .option("--json", "Machine-readable output", false)
+    .option("--quiet", "No spinner/log output (used by background sync)", false)
+    .action(async (action, opts) => memoryCommand(action, opts));
+// Appelée par Claude Code via les hooks — pas par un humain. Cachée du help.
+program
+    .command("hook", { hidden: true })
+    .argument("<event>", "session-start | user-prompt-submit | post-tool-use | session-end")
+    .action(async (event) => hookCommand(event));
 async function main() {
     try {
         await program.parseAsync(process.argv);

package/dist/memory/api.js

@@ -0,0 +1,49 @@
+import { apiUrl, loadConfig } from "../lib/config.js";
+import { AuthError } from "../lib/api.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// REMPLACE src/memory/api.ts du livrable précédent.
+// Changement: repo passé en query param (?repo=owner/name) au lieu d'un segment
+// de path — un "/" encodé dans un segment dynamique Next.js/Vercel est fragile.
+// Endpoints implémentés côté kurtel-app:
+//   GET  /api/memory/patterns?repo=...&since=...
+//   PUT  /api/memory/index?repo=...
+//   POST /api/memory/telemetry?repo=...
+// ─────────────────────────────────────────────────────────────────────────────
+async function authed(method, path, body) {
+    const token = loadConfig().token;
+    if (!token)
+        throw new AuthError("Not signed in. Run `kurtel login`.");
+    const res = await fetch(`${apiUrl()}${path}`, {
+        method,
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    const text = await res.text();
+    let data = {};
+    try {
+        data = text ? JSON.parse(text) : {};
+    }
+    catch { /* non-JSON */ }
+    if (res.status === 401)
+        throw new AuthError("Your session is invalid or expired. Run `kurtel login`.");
+    if (!res.ok)
+        throw new Error(data?.error ?? `error ${res.status}`);
+    return data;
+}
+const q = (repo, extra = {}) => "?" + new URLSearchParams({ repo, ...extra }).toString();
+/** Pull delta de la mémoire darwinienne (repo_skills côté backend). */
+export function pullPatterns(repo, since) {
+    return authed("GET", `/api/memory/patterns${q(repo, since ? { since } : {})}`);
+}
+/** Push de la mémoire de codebase (digest, jamais le code source). */
+export function pushIndex(repo, index) {
+    const digest = {
+        ...index,
+        modules: index.modules.map((m) => ({ ...m, exports: m.exports.slice(0, 10) })).slice(0, 3000),
+    };
+    return authed("PUT", `/api/memory/index${q(repo)}`, digest);
+}
+/** Push asynchrone de la télémétrie d'usage des patterns. */
+export function pushTelemetry(repo, events) {
+    return authed("POST", `/api/memory/telemetry${q(repo)}`, { events });
+}

package/dist/memory/capsule.js

@@ -0,0 +1,137 @@
+import { findSimilarRoutes } from "./indexer.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// Capsule — le cœur du produit. À chaque prompt:
+//   intention → résolution spatiale (zones du graphe) → sélection de patterns
+//   → capsule compacte (budget ~400 tokens) injectée via le hook.
+// Tout se calcule en local, en millisecondes, sans réseau.
+// ─────────────────────────────────────────────────────────────────────────────
+const TOKEN_BUDGET_CHARS = 1600; // ~400 tokens
+const STOPWORDS = new Set([
+    "the", "a", "an", "to", "for", "of", "in", "on", "and", "or", "with", "add",
+    "create", "make", "fix", "update", "change", "new", "page", "file", "please",
+    "le", "la", "les", "un", "une", "des", "de", "du", "et", "ou", "pour", "dans",
+    "ajoute", "ajouter", "crée", "creer", "modifie", "modifier", "corrige", "il", "faut",
+]);
+export function tokenize(text) {
+    return [...new Set(text.toLowerCase()
+            .split(/[^a-z0-9_]+/)
+            .filter((w) => w.length >= 3 && !STOPWORDS.has(w)))];
+}
+// ── Résolution spatiale: quelles zones du repo l'intention touche-t-elle ? ──
+export function resolveZones(index, promptTokens) {
+    const scores = new Map();
+    for (const m of index.modules) {
+        const hay = m.id.toLowerCase();
+        let s = 0;
+        for (const t of promptTokens)
+            if (hay.includes(t))
+                s += 2;
+        for (const e of m.exports) {
+            const el = e.toLowerCase();
+            for (const t of promptTokens)
+                if (el.includes(t))
+                    s += 1;
+        }
+        if (s > 0) {
+            const zone = m.id.includes("/") ? m.id.split("/").slice(0, 2).join("/") : m.id;
+            scores.set(zone, (scores.get(zone) ?? 0) + s);
+        }
+    }
+    return [...scores.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([z]) => z);
+}
+export function selectPatterns(patterns, promptTokens, zones, max = 5) {
+    const out = [];
+    for (const p of patterns) {
+        if (p.score < 0.3 && !p.pinned)
+            continue; // les mourants ne parlent plus
+        let s = 0;
+        if (p.pinned)
+            s += 10; // socle: toujours présent
+        for (const trig of p.triggers) {
+            const tl = trig.toLowerCase();
+            if (promptTokens.some((t) => t === tl || tl.includes(t) || t.includes(tl)))
+                s += 4;
+        }
+        for (const z of p.zones) {
+            if (zones.some((zone) => zone.startsWith(z) || z.startsWith(zone)))
+                s += 3;
+        }
+        if (p.zones.length === 0 && s > 0)
+            s += 1; // global + déjà pertinent
+        if (s > 0)
+            out.push({ pattern: p, score: s * (0.5 + p.score) });
+    }
+    return out.sort((a, b) => b.score - a.score).slice(0, max);
+}
+// ── Routes pertinentes pour l'intention (anti-duplication proactive) ────────
+export function relevantRoutes(index, promptTokens) {
+    const scored = index.routes.map((r) => {
+        const hay = `${r.path} ${r.file}`.toLowerCase();
+        let s = 0;
+        for (const t of promptTokens)
+            if (hay.includes(t))
+                s++;
+        return { r, s };
+    });
+    return scored.filter((x) => x.s > 0).sort((a, b) => b.s - a.s).slice(0, 6).map((x) => x.r);
+}
+export function compileCapsule(index, patterns, prompt) {
+    const tokens = tokenize(prompt);
+    if (!tokens.length)
+        return null;
+    const zones = index ? resolveZones(index, tokens) : [];
+    const selected = selectPatterns(patterns, tokens, zones);
+    const routes = index ? relevantRoutes(index, tokens) : [];
+    const gods = index
+        ? index.god_nodes.filter((g) => zones.some((z) => g.id.startsWith(z))).slice(0, 2)
+        : [];
+    if (!selected.length && !routes.length && !gods.length)
+        return null; // le silence est le défaut
+    const parts = [];
+    parts.push(`[Kurtel memory — auto-injected, relevant to this task only]`);
+    if (routes.length) {
+        parts.push(`Existing routes in this area (do NOT recreate; extend or reuse):`);
+        for (const r of routes)
+            parts.push(`- ${r.method} ${r.path} → ${r.file}:${r.line}`);
+    }
+    if (selected.length) {
+        parts.push(`Team conventions learned from merged PRs (follow them):`);
+        for (const { pattern } of selected) {
+            const conf = Math.round(pattern.score * 100);
+            parts.push(`- ${pattern.rule} (confidence ${conf}%)`);
+        }
+    }
+    if (gods.length) {
+        parts.push(`High-coupling modules in this zone — changes here have a wide blast radius, check dependents:`);
+        for (const g of gods)
+            parts.push(`- ${g.id} (${g.degree} edges)`);
+    }
+    let text = parts.join("\n");
+    if (text.length > TOKEN_BUDGET_CHARS)
+        text = text.slice(0, TOKEN_BUDGET_CHARS - 1) + "…";
+    return { text, injectedPatternIds: selected.map((s) => s.pattern.id), zones };
+}
+// ── Capsule de zone (dérive d'intention en cours de session) ────────────────
+export function compileZoneCapsule(index, patterns, filePath) {
+    const zone = filePath.includes("/") ? filePath.split("/").slice(0, 2).join("/") : filePath;
+    const zonePatterns = patterns.filter((p) => p.score >= 0.3 && p.zones.some((z) => zone.startsWith(z) || z.startsWith(zone))).sort((a, b) => b.score - a.score).slice(0, 3);
+    const zoneRoutes = index ? index.routes.filter((r) => r.file.startsWith(zone)).slice(0, 5) : [];
+    if (!zonePatterns.length && !zoneRoutes.length)
+        return null;
+    const parts = [`[Kurtel memory — you just entered zone "${zone}"]`];
+    if (zonePatterns.length) {
+        parts.push(`Conventions for this zone:`);
+        for (const p of zonePatterns)
+            parts.push(`- ${p.rule}`);
+    }
+    if (zoneRoutes.length) {
+        parts.push(`Routes defined here:`);
+        for (const r of zoneRoutes)
+            parts.push(`- ${r.method} ${r.path} (${r.file}:${r.line})`);
+    }
+    let text = parts.join("\n");
+    if (text.length > 800)
+        text = text.slice(0, 799) + "…";
+    return { text, injectedPatternIds: zonePatterns.map((p) => p.id), zones: [zone] };
+}
+export { findSimilarRoutes };

package/dist/memory/indexer.js

@@ -0,0 +1,280 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative, extname, dirname } from "node:path";
+import { execSync } from "node:child_process";
+import { repoFullName } from "./store.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// Indexeur structurel — 100% local, 0 token, déterministe (même input → même
+// output). Heuristiques regex pragmatiques pour TS/JS/Python ; le point
+// d'extension propre pour passer à tree-sitter plus tard est extractFile().
+// ─────────────────────────────────────────────────────────────────────────────
+const CODE_EXT = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"]);
+const IGNORE_DIRS = new Set([
+    "node_modules", ".git", "dist", "build", "out", ".next", ".nuxt", "coverage",
+    "vendor", "__pycache__", ".venv", "venv", ".kurtel", ".claude", ".idea", ".vscode",
+]);
+// Filtrage anti-bruit (la leçon Graphify) : on indexe le code, pas les assets/config.
+const IGNORE_FILES = /\.(min\.js|d\.ts|test\.[jt]sx?|spec\.[jt]sx?|stories\.[jt]sx?)$|(^|\/)(conftest|setup)\.py$/;
+// Patterns par langage — jamais croisés (sinon `@app.get(...)` Python matche aussi le pattern Express).
+const JS_ROUTE_PATTERNS = [
+    // Express / Fastify / Koa-router (router.get("/x"), app.post('/y'))
+    {
+        re: /\b(?:app|router|server|api|fastify)\s*\.\s*(get|post|put|patch|delete|head|options|all)\s*\(\s*["'`]([^"'`]+)["'`]/g,
+        framework: "express-like",
+        method: (m) => m[1].toUpperCase(),
+        path: (m) => m[2],
+    },
+    // Décorateurs Nest: @Get("/x"), @Post()
+    {
+        re: /@(Get|Post|Put|Patch|Delete|Head|Options)\s*\(\s*(?:["'`]([^"'`]*)["'`])?\s*\)/g,
+        framework: "nest",
+        method: (m) => m[1].toUpperCase(),
+        path: (m) => m[2] ?? "",
+    },
+];
+const PY_ROUTE_PATTERNS = [
+    // FastAPI / Flask: @app.get("/x"), @router.post("/y"), @app.route("/z", methods=["POST"])
+    {
+        re: /@\s*[\w.]+\.(get|post|put|patch|delete|route)\s*\(\s*["']([^"']+)["']/g,
+        framework: "python",
+        method: (m) => (m[1] === "route" ? "*" : m[1].toUpperCase()),
+        path: (m) => m[2],
+    },
+];
+const NEXT_ROUTE_FILE = /(^|\/)(pages|app)\/(.+?)\/?(route|page|index)?\.(ts|tsx|js|jsx)$/;
+function extractFile(root, rel, src) {
+    const lines = src.split("\n");
+    const facts = { rel, loc: lines.length, exports: [], importSpecs: [], routes: [] };
+    const ext = extname(rel);
+    if (ext === ".py") {
+        for (const m of src.matchAll(/^\s*(?:from\s+([\w.]+)\s+import|import\s+([\w.]+))/gm)) {
+            facts.importSpecs.push(m[1] ?? m[2]);
+        }
+        for (const m of src.matchAll(/^(?:def|class)\s+(\w+)/gm))
+            facts.exports.push(m[1]);
+    }
+    else {
+        for (const m of src.matchAll(/\bfrom\s+["']([^"']+)["']|\brequire\s*\(\s*["']([^"']+)["']\s*\)/g)) {
+            facts.importSpecs.push(m[1] ?? m[2]);
+        }
+        for (const m of src.matchAll(/\bexport\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var|interface|type|enum)\s+(\w+)/g)) {
+            facts.exports.push(m[1]);
+        }
+    }
+    // Routes par appel/décorateur, avec n° de ligne — patterns du bon langage uniquement.
+    const routePatterns = ext === ".py" ? PY_ROUTE_PATTERNS : JS_ROUTE_PATTERNS;
+    for (const p of routePatterns) {
+        for (const m of src.matchAll(p.re)) {
+            const upto = src.slice(0, m.index ?? 0);
+            facts.routes.push({
+                method: p.method(m),
+                path: p.path(m),
+                file: rel,
+                line: upto.split("\n").length,
+                framework: p.framework,
+            });
+        }
+    }
+    // Routes par convention de fichier (Next.js app/pages router).
+    const nm = rel.replace(/\\/g, "/").match(NEXT_ROUTE_FILE);
+    if (nm) {
+        const urlPath = "/" + nm[3].replace(/\[(\w+)\]/g, ":$1").replace(/\/index$/, "");
+        facts.routes.push({ method: "*", path: urlPath, file: rel, line: 1, framework: "next" });
+    }
+    return facts;
+}
+// ── Résolution d'imports internes (TS/JS relatifs + Python par module path) ──
+function resolveImports(all) {
+    const byNoExt = new Map();
+    for (const rel of all.keys()) {
+        const noExt = rel.replace(/\.(ts|tsx|js|jsx|mjs|cjs|py)$/, "");
+        byNoExt.set(noExt.replace(/\\/g, "/"), rel);
+        if (noExt.endsWith("/index"))
+            byNoExt.set(noExt.slice(0, -"/index".length), rel);
+        if (noExt.endsWith("/__init__"))
+            byNoExt.set(noExt.slice(0, -"/__init__".length), rel);
+    }
+    const resolved = new Map();
+    for (const [rel, facts] of all) {
+        const targets = [];
+        for (const spec of facts.importSpecs) {
+            let candidate;
+            if (spec.startsWith(".")) {
+                // relatif TS/JS
+                const base = join(dirname(rel), spec).replace(/\\/g, "/").replace(/\.(js|ts|tsx|jsx)$/, "");
+                candidate = byNoExt.get(base);
+            }
+            else if (spec.includes(".") && extname(rel) === ".py") {
+                // module python "app.services.billing" → app/services/billing.py
+                candidate = byNoExt.get(spec.replace(/\./g, "/"));
+            }
+            else {
+                // alias absolu fréquent: "src/lib/foo", "@/lib/foo"
+                const cleaned = spec.replace(/^@\//, "src/").replace(/^~\//, "src/");
+                candidate = byNoExt.get(cleaned);
+            }
+            if (candidate && candidate !== rel)
+                targets.push(candidate);
+        }
+        resolved.set(rel, [...new Set(targets)]);
+    }
+    return resolved;
+}
+// ── Parcours ────────────────────────────────────────────────────────────────
+function* walk(dir, root) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        if (name.startsWith(".") && name !== ".")
+            continue;
+        const full = join(dir, name);
+        let st;
+        try {
+            st = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory()) {
+            if (!IGNORE_DIRS.has(name))
+                yield* walk(full, root);
+        }
+        else if (st.isFile() && st.size < 1_000_000) {
+            const rel = relative(root, full).replace(/\\/g, "/");
+            if (CODE_EXT.has(extname(name)) && !IGNORE_FILES.test(rel))
+                yield rel;
+        }
+    }
+}
+// ── Construction de l'index ─────────────────────────────────────────────────
+export function buildIndex(root, onProgress) {
+    const files = new Map();
+    let n = 0;
+    for (const rel of walk(root, root)) {
+        try {
+            const src = readFileSync(join(root, rel), "utf8");
+            files.set(rel, extractFile(root, rel, src));
+            if (onProgress && ++n % 50 === 0)
+                onProgress(n);
+        }
+        catch { /* binaire/illisible: skip */ }
+    }
+    const imports = resolveImports(files);
+    const inDegree = new Map();
+    for (const targets of imports.values()) {
+        for (const t of targets)
+            inDegree.set(t, (inDegree.get(t) ?? 0) + 1);
+    }
+    const modules = [...files.entries()]
+        .map(([rel, f]) => {
+        const out = imports.get(rel) ?? [];
+        return {
+            id: rel,
+            exports: f.exports.slice(0, 30),
+            imports: out,
+            loc: f.loc,
+            degree: out.length + (inDegree.get(rel) ?? 0),
+        };
+    })
+        .sort((a, b) => a.id.localeCompare(b.id)); // tri stable → déterminisme
+    const god_nodes = [...modules]
+        .sort((a, b) => b.degree - a.degree || a.id.localeCompare(b.id))
+        .slice(0, 10)
+        .filter((m) => m.degree >= 5)
+        .map((m) => ({ id: m.id, degree: m.degree }));
+    const domainMap = new Map();
+    for (const m of modules) {
+        const top = m.id.includes("/") ? m.id.split("/")[0] : "(root)";
+        const d = domainMap.get(top) ?? { files: 0, loc: 0 };
+        d.files += 1;
+        d.loc += m.loc;
+        domainMap.set(top, d);
+    }
+    const domains = [...domainMap.entries()]
+        .map(([name, d]) => ({ name, ...d }))
+        .sort((a, b) => b.loc - a.loc);
+    const routes = [...files.values()].flatMap((f) => f.routes)
+        .sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+    let commit = "unknown";
+    try {
+        commit = execSync("git rev-parse HEAD", { cwd: root, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    }
+    catch { /* pas un repo git */ }
+    return {
+        version: 1,
+        repo: repoFullName(root),
+        commit,
+        generated_at: new Date().toISOString(),
+        files_indexed: files.size,
+        routes,
+        modules,
+        god_nodes,
+        domains,
+    };
+}
+// ── Rapport d'audit (le "moment wow" du jour 0) ─────────────────────────────
+export function renderReport(index) {
+    const lines = [];
+    lines.push(`# Kurtel — Architecture Report`);
+    lines.push(``);
+    lines.push(`Repo **${index.repo}** · ${index.files_indexed} files indexed · commit \`${index.commit.slice(0, 8)}\` · ${index.generated_at}`);
+    lines.push(``);
+    lines.push(`## Domains`);
+    for (const d of index.domains.slice(0, 12)) {
+        lines.push(`- **${d.name}** — ${d.files} files, ${d.loc.toLocaleString()} LOC`);
+    }
+    lines.push(``);
+    if (index.god_nodes.length) {
+        lines.push(`## God nodes (high-coupling hotspots)`);
+        lines.push(`These modules concentrate the most connections; changes here have the widest blast radius.`);
+        for (const g of index.god_nodes) {
+            lines.push(`- \`${g.id}\` — **${g.degree} edges**`);
+        }
+        lines.push(``);
+    }
+    lines.push(`## Route inventory (${index.routes.length})`);
+    lines.push(`The agent receives this inventory before creating any endpoint — duplicates get flagged.`);
+    const byFw = new Map();
+    for (const r of index.routes) {
+        const arr = byFw.get(r.framework) ?? [];
+        arr.push(r);
+        byFw.set(r.framework, arr);
+    }
+    for (const [fw, rs] of byFw) {
+        lines.push(``);
+        lines.push(`### ${fw}`);
+        for (const r of rs.slice(0, 80)) {
+            lines.push(`- \`${r.method.padEnd(6)} ${r.path}\` → ${r.file}:${r.line}`);
+        }
+        if (rs.length > 80)
+            lines.push(`- … and ${rs.length - 80} more`);
+    }
+    lines.push(``);
+    return lines.join("\n");
+}
+// ── Recherche de routes proches (anti-duplication) ──────────────────────────
+/** Similarité grossière entre deux chemins de route (segments partagés, params normalisés). */
+function routeSimilarity(a, b) {
+    const norm = (p) => p.replace(/:(\w+)|\{(\w+)\}|\[(\w+)\]/g, ":p").toLowerCase()
+        .split("/").filter(Boolean);
+    const sa = norm(a), sb = norm(b);
+    if (!sa.length || !sb.length)
+        return 0;
+    let shared = 0;
+    for (let i = 0; i < Math.min(sa.length, sb.length); i++)
+        if (sa[i] === sb[i])
+            shared++;
+    return (2 * shared) / (sa.length + sb.length);
+}
+export function findSimilarRoutes(index, path, threshold = 0.6) {
+    return index.routes
+        .map((r) => ({ r, s: routeSimilarity(r.path, path) }))
+        .filter((x) => x.s >= threshold)
+        .sort((a, b) => b.s - a.s)
+        .slice(0, 5)
+        .map((x) => x.r);
+}

package/dist/memory/store.js

@@ -0,0 +1,125 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+// ─────────────────────────────────────────────────────────────────────────────
+// Emplacements disque
+//   ~/.kurtel/cache/<repo-slug>/patterns.json   ← mémoire darwinienne (pull Supabase)
+//   <repo>/.kurtel/index.json                   ← mémoire de codebase (déterministe)
+//   <repo>/.kurtel/REPORT.md                    ← rapport d'audit lisible
+//   <repo>/.kurtel/memory.json                  ← état local (on/off, session zones)
+// ─────────────────────────────────────────────────────────────────────────────
+export function repoRoot(cwd = process.cwd()) {
+    try {
+        return execSync("git rev-parse --show-toplevel", { cwd, stdio: ["ignore", "pipe", "ignore"] })
+            .toString().trim();
+    }
+    catch {
+        return cwd;
+    }
+}
+export function repoSlug(root) {
+    // owner/name depuis le remote si possible, sinon basename — slugifié pour un nom de dossier.
+    let name = root.split(/[\\/]/).filter(Boolean).pop() ?? "repo";
+    try {
+        const url = execSync("git remote get-url origin", { cwd: root, stdio: ["ignore", "pipe", "ignore"] })
+            .toString().trim();
+        const m = url.match(/[:/]([^/:]+\/[^/]+?)(?:\.git)?$/);
+        if (m)
+            name = m[1];
+    }
+    catch { /* pas de remote */ }
+    return name.replace(/[^a-zA-Z0-9._-]+/g, "__");
+}
+export function repoFullName(root) {
+    try {
+        const url = execSync("git remote get-url origin", { cwd: root, stdio: ["ignore", "pipe", "ignore"] })
+            .toString().trim();
+        const m = url.match(/[:/]([^/:]+\/[^/]+?)(?:\.git?)?$/);
+        if (m)
+            return m[1].replace(/\.git$/, "");
+    }
+    catch { /* ignore */ }
+    return root.split(/[\\/]/).filter(Boolean).pop() ?? "repo";
+}
+function cacheDir(root) {
+    return join(homedir(), ".kurtel", "cache", repoSlug(root));
+}
+function readJSON(file, fallback) {
+    try {
+        if (!existsSync(file))
+            return fallback;
+        return { ...fallback, ...JSON.parse(readFileSync(file, "utf8")) };
+    }
+    catch {
+        return fallback;
+    }
+}
+function writeJSON(file, data) {
+    const dir = join(file, "..");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(file, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+// ── Cache mémoire darwinienne (par user × repo, hors du repo: ne se versionne pas) ──
+const EMPTY_CACHE = { patterns: [], patterns_synced_at: null, pending_telemetry: [] };
+export function loadMemoryCache(root) {
+    return readJSON(join(cacheDir(root), "memory.json"), EMPTY_CACHE);
+}
+export function saveMemoryCache(root, cache) {
+    writeJSON(join(cacheDir(root), "memory.json"), cache);
+}
+export function queueTelemetry(root, ev) {
+    const cache = loadMemoryCache(root);
+    cache.pending_telemetry.push(ev);
+    // borne dure: jamais plus de 500 événements en attente (pas de croissance infinie)
+    if (cache.pending_telemetry.length > 500) {
+        cache.pending_telemetry = cache.pending_telemetry.slice(-500);
+    }
+    saveMemoryCache(root, cache);
+}
+// ── Index de codebase (dans le repo: partageable, déterministe) ──
+export function indexPath(root) {
+    return join(root, ".kurtel", "index.json");
+}
+export function reportPath(root) {
+    return join(root, ".kurtel", "REPORT.md");
+}
+export function loadIndex(root) {
+    const file = indexPath(root);
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveIndex(root, index) {
+    writeJSON(indexPath(root), index);
+}
+const EMPTY_STATE = { enabled: true, session_zones: {} };
+function statePath(root) {
+    return join(cacheDir(root), "state.json");
+}
+export function loadMemoryState(root) {
+    return readJSON(statePath(root), EMPTY_STATE);
+}
+export function saveMemoryState(root, state) {
+    // garde-fou: ne garder que les 20 dernières sessions
+    const ids = Object.keys(state.session_zones);
+    if (ids.length > 20) {
+        for (const id of ids.slice(0, ids.length - 20))
+            delete state.session_zones[id];
+    }
+    writeJSON(statePath(root), state);
+}
+export function memoryEnabled(root) {
+    return loadMemoryState(root).enabled;
+}
+export function setMemoryEnabled(root, enabled) {
+    const s = loadMemoryState(root);
+    s.enabled = enabled;
+    saveMemoryState(root, s);
+}

package/dist/memory/sync.js

@@ -0,0 +1,70 @@
+import { spawn } from "node:child_process";
+import { loadMemoryCache, saveMemoryCache, repoFullName } from "./store.js";
+import { pullPatterns, pushTelemetry, pushIndex } from "./api.js";
+import { loadIndex } from "./store.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// Sync — règle d'or: AUCUN appel réseau sur le chemin critique d'un prompt.
+// Les hooks lisent le cache local; le sync tourne en arrière-plan (process
+// détaché) au SessionStart et après chaque session.
+// ─────────────────────────────────────────────────────────────────────────────
+/** Sync synchrone (utilisé par `kurtel memory sync` et le process détaché). */
+export async function syncNow(root) {
+    const repo = repoFullName(root);
+    const cache = loadMemoryCache(root);
+    // 1. Pull delta des patterns darwiniens.
+    let pulled = 0;
+    try {
+        const res = await pullPatterns(repo, cache.patterns_synced_at);
+        if (res.delta) {
+            const byId = new Map(cache.patterns.map((p) => [p.id, p]));
+            for (const p of res.patterns)
+                byId.set(p.id, p);
+            cache.patterns = [...byId.values()].filter((p) => p.score > 0); // score 0 = mort, purgé
+        }
+        else {
+            cache.patterns = res.patterns;
+        }
+        cache.patterns_synced_at = res.synced_at;
+        pulled = res.patterns.length;
+    }
+    catch { /* offline / pas loggé: le cache continue de servir */ }
+    // 2. Flush de la télémétrie en attente.
+    let flushed = 0;
+    if (cache.pending_telemetry.length) {
+        try {
+            await pushTelemetry(repo, cache.pending_telemetry);
+            flushed = cache.pending_telemetry.length;
+            cache.pending_telemetry = [];
+        }
+        catch { /* on réessaiera au prochain sync */ }
+    }
+    saveMemoryCache(root, cache);
+    return { pulled, flushed };
+}
+/** Push de l'index de codebase vers le backend (pour l'onglet Memory in-app). */
+export async function syncIndexUp(root) {
+    const index = loadIndex(root);
+    if (!index)
+        return false;
+    try {
+        await pushIndex(index.repo, index);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Lance un sync en arrière-plan, détaché — fire & forget, jamais bloquant. */
+export function syncInBackground(root) {
+    try {
+        const child = spawn(process.execPath, [process.argv[1], "memory", "sync", "--quiet"], {
+            cwd: root,
+            stdio: "ignore",
+            detached: true,
+            env: process.env,
+        });
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch { /* best effort */ }
+}

package/dist/ui/banner.js

@@ -2,10 +2,11 @@ import { c, symbols } from "./colors.js";
 import { box } from "./box.js";
 import { getVersion } from "../lib/version.js";
 const wordmark = [
-    "  _  __         _       _ ",
-    " | |/ /  _ _ _ | |_ ___| |",
-    " | ' <  | '_| || |  _/ -_) |",
-    " |_|\\_\\ |_|  \\_,_|\\__\\___|_|",
+    " _  __          _       _ ",
+    "| |/ /   _ _ __| |_ ___| |",
+    "| ' / | | | '__| __/ _ \\ |",
+    "| . \\ |_| | |  | ||  __/ |",
+    "|_|\\_\\__,_|_|   \\__\\___|_|",
 ];
 export function banner() {
     const art = wordmark.map((l) => c.indigoBold(l)).join("\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kurtel/cli",
-  "version": "0.1.8",
+  "version": "0.1.12",
   "description": "Launch self-improving coding agents in the cloud — the Kurtel CLI.",
   "type": "module",
   "bin": {