@nanonets/graft 0.24.0 → 0.24.1

package/dist/cli.js

@@ -41,6 +41,7 @@ import { planInit, selectedWrites } from "./hosts/plan.js";
 import { planRetract, runRetract, changed } from "./hosts/retract.js";
 import { compactWrites, formatNonInteractiveHelp, formatPlan, pickLearnings, runPicker } from "./cli-picker.js";
 import { buildGraphWithProgress } from "./claude/build-progress.js";
+import { installBrainsServer, removeBrainsServer } from "./hosts/claude-global.js";
 import { homedir } from "node:os";
 import { formatUpgradeReport, formatVersionReport, getNpmViewVersion, readCurrentVersion, readPackageName, runUpgrade } from "./cli-meta.js";
 import { nativeFallbackNotice } from "./graph/native.js";
@@ -52,13 +53,17 @@ import { costLabel, listNotes, noteName, notePlace, noteTargets, readingTokens,
 import { findLearning, liveLearnings } from "./notes/learning-fields.js";
 import { aboutTerms, currentSessionCost } from "./notes/session-cost.js";
 import { beginPastRead, finishPastRead } from "./notes/cold-start.js";
+import { skippedSkillLines } from "./skills/found-skill.js";
 import { anchoredReviews, beginReviewRead, finishReviewRead } from "./notes/pr-reviews.js";
 import { finishMemoryRead, memoryCandidates, offeredBefore } from "./notes/memory-notes.js";
+import { finishPair, PairRun, validPairCode } from "./cloud/pair.js";
 import { currentBranch, noteAuthor, teammatesOn } from "./notes/git-facts.js";
 import { gateNote, namesRepoSymbol, symbolCandidates, trackedFiles } from "./notes/note-gate.js";
 import { confirm, fold, getSkill, learn, listSkills, publish, skillForAgent, skillName, skillStatus } from "./skills/skills.js";
+import { recordLookup } from "./cloud/lookup-activity.js";
 import { clearPending, cloudLines, loginLink, sessionKey, waitForConnect } from "./cloud/nudge.js";
-import { addRepo, clearCloud, cloudEnabled, fetchMe, fetchTeam, isError, readCloud, writeCloud } from "./cloud/workspace.js";
+import { addRepo, clearCloud, cloudEnabled, fetchMe, fetchTeam, isError, readCloud, trailUrl, writeCloud } from "./cloud/workspace.js";
+import { claimConnectCode, connectAgain, offlineLine, learningsSummary, machineName, normalizeCode, OnboardingReporter, repoRef, teammatesChecked, teammatesFromGit, tokensOnOneLookup, } from "./cloud/onboarding.js";
 import { inWorkspace, maybeSyncInBackground, recordActivity, runSyncChild, syncRepo } from "./cloud/workspace-sync.js";
 import { checkLocally } from "./check/local-check.js";
 import { formatOverlap, maybeRefreshBranches, overlapsWith, pushedWhen, readBranchCache, refreshBranches } from "./notes/branches.js";
@@ -307,6 +312,14 @@ program
     .action(async () => {
     await waitForConnect();
 });
+program
+    .command("_trail-pair", { hidden: true })
+    .description("internal: after `init --pair`, wait for the connect and the review in the browser, then upload the repo's learnings")
+    .argument("<state>")
+    .argument("<dir>")
+    .action(async (state, dir) => {
+    await finishPair(state, resolve(dir));
+});
 program
     .command("_update-check", { hidden: true })
     .description("internal: refresh the cached latest-version answer")
@@ -622,39 +635,27 @@ grouped(program.command("build"), GROUP.setup)
         }
     }
 });
-/** The file part of a hit's `file:Lx-Ly` pointer. */
-function pointerFile(pointer) {
-    return pointer.replace(/:L\d+(-L?\d+)?$/, "");
-}
 /**
  * After `ask`, under trail: which shown learnings are a teammate's, and the
- * shown learnings recorded as a use, which is what the team page counts as
- * reuse. Then the background upkeep that keeps branches and the workspace
- * current. Spawns no git itself. Teammates' branches come up after an edit
+ * lookup recorded (the learnings shown are a use, which is what the team page
+ * counts as reuse; the tokens saved ride along). Then the background upkeep
+ * that keeps branches and the workspace current. Spawns no git itself. Teammates' branches come up after an edit
  * instead, once there's a function to compare (notes/edit-overlap.ts).
  */
 function afterAsk(r, repo) {
+    // Every lookup is reported, not only ones that showed a learning: the tokens
+    // the map saved are what the team page's running total counts. A no-op unless
+    // this machine is connected and the repo is the workspace's.
+    recordLookup(r, repo);
     if (!r.notesChecked)
         return;
     rememberRepo(repo);
     maybeRefreshBranches(repo);
     const me = noteAuthor(repo);
-    const files = [...new Set(r.hits.map((h) => pointerFile(h.pointer)))];
     const shown = r.notes ?? [];
     if (shown.length) {
         for (const h of shown)
             h.note.teammate = !!h.note.author && !!me && h.note.author !== me;
-        recordActivity({
-            repo: repoPlace(repo).key,
-            kind: "search",
-            asker: me,
-            session: sessionKey(repo) ?? `${me}-${new Date().toISOString().slice(0, 10)}`,
-            query: r.query,
-            files,
-            shown_paths: shown.map((h) => noteName(h.note)),
-            shown_authors: shown.map((h) => h.note.author),
-            at: new Date().toISOString(),
-        });
         const saved = shown.reduce((sum, h) => sum + savedByNote(h.note), 0);
         track("learning_reused", { teammate: String(shown.some((h) => h.note.teammate)), saved_tokens_bucket: savedTokensBucket(saved) }, { repo });
     }
@@ -853,9 +854,14 @@ program
     .command("mcp", { hidden: TRAIL })
     .description("Serve the graph over MCP (stdio) — exposes graft_find_code, graft_trace_calls, graft_find_all, graft_file_api, graft_repo_map and graft_check_freshness as tools")
     .argument(...DIR_ARG)
-    .action(async (dirArg) => {
-    const dir = noteQuery(queryRoot(dirArg));
+    .option("--brains", "serve only the connected Trail workspace's brain tools (what Claude Code gets after init --connect)")
+    .action(async (dirArg, opts) => {
     const { startMcpServer } = await import("./mcp/server.js");
+    if (opts.brains) {
+        startMcpServer(process.cwd(), undefined, currentVersion, { brainsOnly: true });
+        return;
+    }
+    const dir = noteQuery(queryRoot(dirArg));
     const globalOpts = program.opts();
     startMcpServer(dir, globalOpts.dir, currentVersion);
 });
@@ -1172,8 +1178,19 @@ grouped(program.command("init"), GROUP.setup)
     .option("-y, --yes", "skip the picker and wire every detected agent (the pre-0.8 default)")
     .option("--no-global", "skip writes outside this repo (the ~/.codex/ config + hooks)")
     .option("--verbose", "print every file written, the graph build's own output and the closing banner")
+    .option("--connect <code>", "connect this machine to your Trail workspace with the one-time code from team.trailhq.com, and send it a summary of this repo (titles, counts and names; never code)")
+    .option("--pair <code>", "the pair code from Trail's onboarding page: that page shows this run live, then you review what it found")
+    .option("--server <url>", "the Trail that gave the code (default: Trail cloud, https://team.trailhq.com)")
     .action(async (dir, opts) => {
-    await runInitCommand(dir, opts);
+    if (opts.connect !== undefined && opts.pair !== undefined) {
+        console.error("✗ --connect and --pair are two ways in: use the one your Trail page gave you");
+        process.exitCode = 1;
+        return;
+    }
+    if (opts.connect !== undefined)
+        await runConnectInit(dir, opts);
+    else
+        await runInitCommand(dir, opts);
 });
 /** Everything on stdin, or "" when nothing is piped in. */
 async function readStdin() {
@@ -1334,19 +1351,58 @@ function printLines(lines) {
     if (lines.length)
         console.log(`\n${lines.join("\n")}`);
 }
+/**
+ * `--server <url>` on `init --connect` and `--pair`: the Trail that gave the
+ * code, kept for the rest of this run as TRAIL_URL. False, after saying why,
+ * when it isn't a URL.
+ */
+function useServerOption(raw) {
+    const server = raw?.trim().replace(/\/+$/, "");
+    if (!server)
+        return true;
+    if (!/^https?:\/\//.test(server)) {
+        console.error("✗ --server takes a URL, like https://dev.trailhq.com");
+        process.exitCode = 1;
+        return false;
+    }
+    process.env.TRAIL_URL = server;
+    return true;
+}
+/**
+ * What `init --pair` hears from init, as the onboarding page's steps: the map
+ * is done when `mapped` fires, the past sessions when `learned` does. Nothing
+ * to say for a run that read no sessions (that step is already marked).
+ */
+function pairProgress(pair) {
+    return {
+        mapped: (m) => pair.phase("files", "done", m.files ? `${m.files.toLocaleString("en-US")} files` : "", m.files ? `Mapped ${m.files.toLocaleString("en-US")} files` : "Mapped the code"),
+        learned: (l) => {
+            if (l.sessions <= 0)
+                return;
+            // The PR reviews' learnings come with `sessions: 0`; the rest were said in past sessions.
+            const fromSessions = l.notes.filter((n) => n.sessions !== 0).length;
+            pair.phase("decisions", "done", `${l.sessions} sessions`, `Read ${l.sessions} past sessions: ${fromSessions} thing${fromSessions === 1 ? "" : "s"} you told Claude more than once`);
+        },
+    };
+}
 /** Repo-relative with forward slashes, for printing. */
 function shown(repo, path) {
     return relative(repo, path).split("\\").join("/");
 }
+/** Agents init knows by another id: both read AGENTS.md. */
+const AGENT_ALIASES = { codex: "agents", opencode: "agents" };
 /** `graft init`. */
-async function runInitCommand(dir, opts) {
+async function runInitCommand(dir, opts, progress) {
     if (opts.listAgents) {
         for (const id of [...hostIds(), "claude"])
             console.log(id);
         return null;
     }
     const repo = resolve(dir);
-    const explicit = Array.isArray(opts.agents) ? opts.agents : undefined;
+    // Codex and OpenCode read AGENTS.md: `--agents codex` means that wiring.
+    // The name as given is kept for Trail's onboarding page.
+    const asked = Array.isArray(opts.agents) ? opts.agents : undefined;
+    const explicit = asked ? [...new Set(asked.map((id) => AGENT_ALIASES[id] ?? id))] : undefined;
     // Checked before anything is written: run from the home folder, init wired
     // it, mapped every code file under it, then said to commit.
     const refusal = homeFolderRefusal(repo);
@@ -1426,6 +1482,26 @@ async function runInitCommand(dir, opts) {
         console.error("· no agents selected — nothing written");
         return null;
     }
+    // With --pair, Trail's onboarding page is waiting on this run: tell it
+    // first, so the person can sign up while the rest of init runs.
+    let pair = null;
+    if (opts.pair !== undefined) {
+        if (!useServerOption(opts.server))
+            return null;
+        if (!validPairCode(opts.pair)) {
+            console.error(`✗ --pair takes the code from Trail's onboarding page, got "${opts.pair}"`);
+            process.exitCode = 1;
+            return null;
+        }
+        const started = await PairRun.start(repo, opts.pair, { agent: asked?.[0] ?? ids[0], version: currentVersion });
+        if ("error" in started) {
+            console.error(`⚠ couldn't tell Trail about this run (${started.error}); setting up here anyway`);
+        }
+        else {
+            pair = started;
+            console.error(`· Trail's page is following along · ${started.url}`);
+        }
+    }
     const wantClaude = ids.includes("claude");
     const cliPath = fileURLToPath(import.meta.url);
     // Under trail, each repo gets its `.trail/learnings/`, committed with the
@@ -1452,6 +1528,16 @@ async function runInitCommand(dir, opts) {
     const reviewRead = TRAIL && wantClaude ? beginReviewRead(repo) : null;
     if (reviewRead)
         console.error("· reading review comments on this repo's merged PRs for what reviewers keep flagging");
+    if (pair) {
+        if (pastRead)
+            pair.phase("decisions", "running", "", `Reading ${pastRead.sessions} past Claude sessions`);
+        else
+            pair.phase("decisions", "done", "none here");
+        if (reviewRead)
+            pair.phase("prs", "running", "", "Reading review comments on merged PRs");
+        else
+            pair.phase("prs", "done", "none here");
+    }
     if (children.length)
         console.error(`· workspace: wiring ${repo} and ${children.length} child repo(s) — ${children.join(", ")}`);
     // Today's output, file by file, behind --verbose. Everything else gets one
@@ -1467,6 +1553,7 @@ async function runInitCommand(dir, opts) {
     // the workspace build, so it covers every child.
     let graphLine = null;
     if (!verbose) {
+        pair?.phase("files", "running", "", "Mapping the code");
         const res = await buildGraphWithProgress(repo, { build: opts.build, cliPath });
         for (const m of res.messages)
             console.error(m);
@@ -1491,6 +1578,25 @@ async function runInitCommand(dir, opts) {
             graphLine = `· skipped the graph build — run ${cmd("graft build")}`;
         }
     }
+    // --pair hears the same stages --connect does; only the ones InitProgress
+    // has no slot for (a read starting, the PR read, nothing to read) stay inline.
+    const report = pair ? pairProgress(pair) : progress;
+    if (report?.mapped) {
+        const g = loadGraphCached(contextDirFor(repo, children.length ? undefined : program.opts().dir));
+        report.mapped({
+            nodes: g?.meta.nodeCount ?? 0,
+            edges: g?.meta.edgeCount ?? 0,
+            files: g ? g.nodes.filter((n) => n.kind === "file").length : 0,
+        });
+    }
+    // With --pair, one lookup measured against reading the files whole: the
+    // page's token step. It needs the map, so it follows the build.
+    let tokens = null;
+    if (pair) {
+        pair.phase("tokens", "running", "", "Measuring one lookup against reading the files");
+        tokens = tokensOnOneLookup(repo, { contextDir: program.opts().dir });
+        pair.tokensDone(tokens);
+    }
     if (!verbose) {
         // Warnings and removals in full, whatever else is folded.
         const removed = [...new Set(reports.flatMap((r) => r.retracted))];
@@ -1512,6 +1618,7 @@ async function runInitCommand(dir, opts) {
     // what reviewers kept flagging on merged PRs, and Claude Code's notes about
     // the repo on this machine. What the person kept telling Claude is theirs.
     let learnedNow = false;
+    let skillsWritten = [];
     let teamSaved = 0;
     const memory = TRAIL && wantClaude ? memoryCandidates(repo, { offered: offeredBefore(repo) }) : [];
     if (TRAIL && (pastRead || reviewRead || memory.length)) {
@@ -1525,7 +1632,7 @@ async function runInitCommand(dir, opts) {
         // first and ticked, their own unticked. A scripted run, or one with
         // --yes, keeps the team's and what they told Claude. Cancelling saves
         // none, and the next init asks again.
-        const picked = process.stdin.isTTY && process.stderr.isTTY && !opts.yes && fromReviews.length + memory.length + fromSessions.length
+        const picked = process.stdin.isTTY && process.stderr.isTTY && !opts.yes && !pair && fromReviews.length + memory.length + fromSessions.length
             ? await pickLearnings([
                 ...fromReviews.map((f) => ({ title: f.title, forTeam: true, prs: f.prs })),
                 ...memory.map((c) => ({ title: c.title, forTeam: c.forTeam, memory: true })),
@@ -1537,10 +1644,13 @@ async function runInitCommand(dir, opts) {
             ? undefined
             : async (found) => picked && picked.filter((i) => i >= from && i < from + found.length).map((i) => found[i - from]);
         const learned = [];
+        const learnedFrom = [];
+        let sessionsRead = 0;
         // Reviews first: which of them are offered depends on the learnings already saved.
         if (reviewRead) {
             const { result, saved, kept, cancelled } = await finishReviewRead(repo, reviewRead, keepFrom(0));
             const offered = fromReviews.length;
+            pair?.phase("prs", "done", `${result.prs} PRs`, `Read ${result.prs} merged PRs: ${saved.length} thing${saved.length === 1 ? "" : "s"} reviewers made authors change`);
             if (saved.length) {
                 const n = saved.length;
                 const what = n < offered ? `kept ${n} of the ${offered} things` : `learned ${n} thing${n === 1 ? "" : "s"}`;
@@ -1558,6 +1668,9 @@ async function runInitCommand(dir, opts) {
                 console.error(`· couldn't read PR reviews this time; ${cmd("graft init")} again tries again`);
             }
             learned.push(...saved);
+            // Not said in past sessions: `sessions: 0` keeps them out of the page's session count.
+            for (const note of saved)
+                learnedFrom.push({ note, sessions: 0 });
         }
         if (memory.length) {
             const { saved, cancelled } = await finishMemoryRead(repo, memory, keepFrom(fromReviews.length));
@@ -1570,9 +1683,21 @@ async function runInitCommand(dir, opts) {
                 console.error(`· saved none of the ${memory.length} notes your Claude keeps about this repo; ${cmd("graft init")} again asks again`);
             }
             learned.push(...saved);
+            for (const note of saved)
+                learnedFrom.push({ note, sessions: 0 });
         }
         if (pastRead) {
-            const { result, saved, kept, cancelled } = await finishPastRead(repo, pastRead, keepFrom(fromReviews.length + memory.length));
+            const { result, saved, kept, skills, cancelled } = await finishPastRead(repo, pastRead, keepFrom(fromReviews.length + memory.length));
+            sessionsRead = result.read ?? 0;
+            skillsWritten = skills;
+            for (const { skill, path } of skills) {
+                console.error(`✓ wrote a skill from a procedure you walked Claude through more than once: ${skill.title}`);
+                console.error(`    ${skill.for === "team" ? "for your team" : "just for you "} · ${path}`);
+            }
+            if (!cancelled)
+                for (const line of skippedSkillLines(repo, result.skills, skills))
+                    console.error(line);
+            saved.forEach((note, i) => learnedFrom.push({ note, sessions: kept[i]?.sessions.length }));
             const offered = result.findings.length;
             if (saved.length) {
                 const n = saved.length;
@@ -1598,12 +1723,16 @@ async function runInitCommand(dir, opts) {
         }
         learnedNow = learned.length > 0;
         teamSaved = learned.filter((s) => s.scope === "repo").length;
+        report?.learned?.({ notes: learnedFrom, sessions: sessionsRead });
         if (learnedNow) {
             console.error("· Claude follows them from your next session");
             if (teamSaved)
                 console.error(commitLines({}, teammatesOn(repo), "repo").uncommitted);
         }
     }
+    // Nothing read this run (already read once, or not Claude Code): the page still gets its stage.
+    if (!(TRAIL && (pastRead || reviewRead || memory.length)))
+        report?.learned?.({ notes: [], sessions: 0 });
     if (TRAIL && !learnedNow) {
         const home = notesHome.get(repo);
         if (home) {
@@ -1660,14 +1789,130 @@ async function runInitCommand(dir, opts) {
                 nodes: graphs.reduce((n, g) => n + g.meta.nodeCount, 0),
                 edges: graphs.reduce((n, g) => n + g.meta.edgeCount, 0),
             }));
+    // Hand what was found to the review page, and leave a child waiting for
+    // the person to connect and review there.
+    if (pair) {
+        // Teammates' branches on this person's files, checked against the
+        // learnings just saved and the repo's own: synchronous, so the finding
+        // exists before the page is told the read is done.
+        pair.phase("team", "running", "", "Checking your team's branches");
+        const teamNotes = listNotes(repo, { branches: false }).filter((n) => n.scope === "repo" && !n.ref);
+        // No remote (or no default branch) means nothing was checked: `teammates`
+        // is left out, since an empty list would say "checked, none".
+        const teammates = teammatesChecked(repo, { learnings: teamNotes });
+        pair.teamDone(teammates);
+        pair.findings({ tokens, sessions: pastRead?.sessions, teammates });
+        await pair.finish(repo, skillsWritten);
+        pair.handOff(repo);
+        console.error(`✓ Trail has what it found · review it in the browser: ${pair.url}`);
+        if (!process.stdout.isTTY)
+            console.error(`[trail] Tell the user, in one line: their Trail page has moved on; review what Trail found there. If it isn't open, the link is ${pair.url}`);
+    }
     // Run by an agent, not a person: the last line tells it to ask about the
     // commit, since the person never saw the picker and Claude Code folds the rest.
-    if (teamSaved && !process.stderr.isTTY)
+    // With --pair the person reviews them on the Trail page first, so no ask here.
+    if (teamSaved && !pair && !process.stderr.isTTY)
         console.error(`→ ${teamSaved} team learning${teamSaved === 1 ? "" : "s"} in ${LEARNINGS_DIR}/ ${teamSaved === 1 ? "isn't" : "aren't"} committed yet. Ask the user: "Commit ${teamSaved === 1 ? "it" : `the ${teamSaved}`} so your teammates' Claude starts from ${teamSaved === 1 ? "it" : "them"}? (yes / no)"`);
     // Sorted so `claude,cursor` and `cursor,claude` aggregate as one value.
     track("init_completed", { agents: [...ids].sort().join(","), consent: consent === undefined ? "unasked" : String(consent) }, { repo });
     return { ids };
 }
+/**
+ * `trail init --connect <CODE>`: the onboarding on team.trailhq.com. Claims the
+ * one-time code (a wrong or spent one stops here, before anything is written),
+ * saves the workspace token where `trail login` keeps it, then runs init as
+ * usual while the page ticks off connected, mapped and learned. At the end,
+ * one summary of the repo goes up (a lookup's tokens saved, the learnings'
+ * titles, teammates' branches from git: never code, diffs or session text),
+ * then `done`. Offline, init still sets the repo up and says how to connect.
+ */
+async function runConnectInit(dir, opts) {
+    if (opts.listAgents || opts.dryRun) {
+        if (opts.dryRun)
+            console.error("· --dry-run: not connecting");
+        await runInitCommand(dir, opts);
+        return;
+    }
+    const repo = resolve(dir);
+    if (!useServerOption(opts.server))
+        return;
+    const base = trailUrl();
+    const code = normalizeCode(opts.connect ?? "");
+    if (!code) {
+        console.error(`✗ "${opts.connect ?? ""}" isn't a Trail code · it looks like TRL-7F2A-K9QD, from ${base}/welcome/code`);
+        process.exitCode = 1;
+        return;
+    }
+    const ref = repoRef(repo);
+    const machine = machineName();
+    const got = await claimConnectCode(base, code, { machine, repo: ref });
+    const cloud = "cloud" in got ? got.cloud : null;
+    if ("cloud" in got) {
+        const cloud = got.cloud;
+        writeCloud(cloud);
+        // A sign-in link out from before is moot now.
+        clearPending();
+        console.error(`✓ connected to workspace ${cloud.workspace.name}`);
+        track("brain_signup_settled", { outcome: "linked", mode: "connect", duration_bucket: durationBucket(0) }, { repo });
+    }
+    else if (got.reason === "invalid") {
+        console.error(`✗ ${got.error} · get a new code at ${base}/welcome/code`);
+        process.exitCode = 1;
+        return;
+    }
+    else {
+        console.error(offlineLine(got.error, base, code, cmd("graft init")));
+    }
+    const reporter = cloud ? new OnboardingReporter(cloud, ref, { machine }) : null;
+    void reporter?.stage("connected");
+    // What init learned this run, kept for the summary.
+    const heard = { notes: [], sessions: 0 };
+    const progress = reporter
+        ? {
+            mapped: (m) => void reporter.stage("mapped", m),
+            learned: (l) => {
+                Object.assign(heard, l);
+                const team = learningsSummary(repo, l.notes);
+                void reporter.stage("learned", { learnings: team.length, sessions: l.sessions || Math.max(0, ...team.map((t) => t.sessions)) });
+            },
+        }
+        : undefined;
+    // The page's command is pasted into a terminal, but an agent may run it for
+    // them: with no terminal to pick in, wire the agents this machine has.
+    const interactive = process.stdin.isTTY && process.stderr.isTTY;
+    const res = await runInitCommand(dir, interactive ? opts : { ...opts, yes: true }, progress);
+    if (!reporter || !cloud)
+        return;
+    if (!res) {
+        await reporter.flush();
+        return;
+    }
+    // What Trail found, for the page: route B, summaries only.
+    const learnings = learningsSummary(repo, heard.notes);
+    const sessions = heard.sessions || Math.max(0, ...learnings.map((l) => l.sessions));
+    const tokens = tokensOnOneLookup(repo, { contextDir: program.opts().dir });
+    const teamNotes = listNotes(repo, { branches: false }).filter((n) => n.scope === "repo" && !n.ref);
+    const teammates = teammatesFromGit(repo, { learnings: teamNotes });
+    const sent = await reporter.summary({ tokens, ...(sessions ? { sessions } : {}), learnings, teammates });
+    await reporter.stage("done");
+    await reporter.flush();
+    // Claude Code gets the workspace's brains through one user-level `trail` entry.
+    const brainsEntry = res.ids.includes("claude") && opts.global !== false ? installBrainsServer(homedir()) : null;
+    if (sent) {
+        const parts = [
+            tokens ? `one lookup saved ${tokens.pct}% of the tokens` : null,
+            `${learnings.length} learning${learnings.length === 1 ? "" : "s"}`,
+            `${teammates.length} teammate branch${teammates.length === 1 ? "" : "es"} on your files`,
+        ].filter(Boolean);
+        console.error(`✓ sent ${cloud.workspace.name} a summary: ${parts.join(", ")} · titles, counts and names only, no code`);
+        console.error(`· see what Trail found: ${base}/welcome/code/found`);
+    }
+    else {
+        console.error(`· couldn't send the summary to Trail this time · with a new code from ${base}/welcome/code, ${connectAgain(cmd("graft init"), "<code>", base)} sends it again`);
+    }
+    if (brainsEntry?.action === "created" || brainsEntry?.action === "updated")
+        console.error(`✓ Claude Code gets your workspace's brains in every project · restart it to pick them up`);
+}
 /** One repo's worth of `init` writes — the parent, then each workspace child. */
 function wireTarget(repo, ids, ctx) {
     const { home, cliPath, plan, wantClaude } = ctx;
@@ -1829,7 +2074,7 @@ function loginCommand(name = "login") {
     return new Command(name)
         .description("Connect this machine to a Trail workspace: sign in, pick the repos it gets, invite your team")
         .argument("[dir]", "the repo you're in, ticked first in the picker", ".")
-        .option("--server <url>", "a self-hosted Trail, e.g. https://trail.acme.internal (default: Trail cloud)")
+        .option("--server <url>", "a self-hosted Trail, e.g. https://trail.acme.internal (default: Trail cloud, https://team.trailhq.com)")
         .action(async (dir, opts) => {
         const repo = resolve(dir);
         const server = opts.server?.trim().replace(/\/+$/, "");
@@ -1869,6 +2114,7 @@ function logoutCommand(name = "logout") {
         .action(() => {
         const cloud = readCloud();
         clearPending();
+        removeBrainsServer(homedir());
         if (!clearCloud()) {
             console.error("· not connected to a workspace");
             return;
@@ -2250,6 +2496,9 @@ function statusCommand(name = "status") {
             if (cloudEnabled())
                 row("workspace", "not connected · Claude offers a link once there are learnings to share");
         }
+        else if (cloud.via === "connect") {
+            row("workspace", `${cloud.workspace.name} · gets a summary of the repos you run ${cmd("graft init")} --connect in · ${cloud.workspace.url}`);
+        }
         else
             row("workspace", `${cloud.workspace.name} · ${cloud.repos.length} repo${cloud.repos.length === 1 ? "" : "s"}${shared ? ", this one included" : `, not this one (${cmd("graft workspace add")})`} · ${cloud.workspace.url}`);
         row("this week", saved > 0 ? `~${shortCount(saved)} tokens saved` : "nothing saved yet");