@nanonets/graft 0.23.1 → 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";
@@ -49,13 +50,20 @@ import { normalizePathPrefix } from "./util/paths.js";
 import { latestSession, formatSessionStats, sessionInputRate } from "./claude/session-metrics.js";
 import { listSessionIds, readSession, sessionDir } from "./claude/state.js";
 import { costLabel, listNotes, noteName, notePlace, noteTargets, readingTokens, savedByNote, commitLines, PERSONAL_SAVED_LINE, PR_SPEEDUP, SECTIONS, tokensWorthSaying, sectionLead, shortDate, tokensLabel, writeNote, mentionedFiles } from "./notes/notes.js";
+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 { beginReviewRead, finishReviewRead } from "./notes/pr-reviews.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";
@@ -304,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")
@@ -390,6 +406,8 @@ grouped(program.command("build"), GROUP.setup)
     .option("--deep", "run the LLM pass: concept nodes (graft/*.md) + per-symbol summary/crux")
     .option("-e, --extensions <exts...>", 'code extensions to include (e.g. ".ts" ".py"); an extension with no parser is ignored with a warning that lists the supported set')
     .option("-j, --concurrency <n>", "files summarized in parallel during --deep (default 5)")
+    .option("--synth-concurrency <n>", "concept synthesis batches in flight at once during --deep (default 4). Separate from -j: " +
+    "each synthesis call carries a whole batch of summaries, not one file")
     .option("--no-reuse", "re-parse every file instead of replaying unchanged ones from the extraction cache")
     .option("--lsp", "add compiler-grade call edges via a language server if one is installed (opt-in, slower; e.g. rust-analyzer, clangd)")
     .option("--allow-partial", "with --deep: exit 0 even when some files' summaries failed (default: a degraded meaning tier exits 1)")
@@ -423,6 +441,11 @@ grouped(program.command("build"), GROUP.setup)
         console.error(`✗ --concurrency must be a number, got "${opts.concurrency}"`);
         process.exit(1);
     }
+    const synthConcurrency = opts.synthConcurrency ? Math.max(1, Number(opts.synthConcurrency)) : undefined;
+    if (opts.synthConcurrency && !Number.isFinite(synthConcurrency)) {
+        console.error(`✗ --synth-concurrency must be a number, got "${opts.synthConcurrency}"`);
+        process.exit(1);
+    }
     warnUnsupportedExtensions(opts.extensions);
     // Persisted BEFORE the build itself runs, so this invocation's walks (and
     // every later no-flag build / hooks refresh) see it identically — the
@@ -499,6 +522,7 @@ grouped(program.command("build"), GROUP.setup)
             deep: !!deep,
             extensions: opts.extensions,
             concurrency,
+            synthConcurrency,
             childConfig: cliConfig(),
             override: buildGlobalDir,
             includeDirs: opts.includeDir,
@@ -515,6 +539,7 @@ grouped(program.command("build"), GROUP.setup)
         const c = await engine.init(dir, {
             extensions: opts.extensions,
             onlyDirs,
+            synthConcurrency,
             onProgress: ({ phase, index, total, file }) => process.stderr.write(`\r${phase === "summarize" ? "reading" : "writing"} concepts ${index + 1}/${total}: ${file.slice(0, 40).padEnd(40)}`),
         }).catch((err) => {
             // Only the stage and a code enum; the message stays on this machine.
@@ -522,7 +547,11 @@ grouped(program.command("build"), GROUP.setup)
             throw err;
         });
         process.stderr.write("\n");
-        console.log(`✓ concepts: ${c.nodes} nodes, ${c.links} links from ${c.files} files (${c.summarized} read, ${c.cached} cached)`);
+        const conceptLine = `concepts: ${c.nodes} nodes, ${c.links} links from ${c.files} files (${c.summarized} read, ${c.cached} cached)`;
+        if (c.nodes === 0)
+            console.error(`⚠ ${conceptLine}`);
+        else
+            console.log(`✓ ${conceptLine}`);
         for (const e of c.errors)
             console.error(`✗ ${e}`);
         conceptErrors = c.errors;
@@ -606,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 });
     }
@@ -837,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);
 });
@@ -984,6 +1006,8 @@ grouped(program.command("note", { hidden: !TRAIL }), GROUP.memory)
     .option("--author <name>", "who wrote it (default: the first word of git config user.name)")
     .option("--minutes <n>", "what it took to work out, when the agent's transcript can't say")
     .option("--tokens <n>", "the same, in tokens")
+    .option("--replaces <file>", "an earlier learning this one takes over from (its file name in .trail/learnings/); the old file stays")
+    .option("--anyway", "save it even if trail's checks (names code, says why, not status, not a repeat) turn it away")
     .option("--json", "print the saved learning as JSON")
     .argument("[dir]", "repository root", ".")
     .action(async (dir, opts) => {
@@ -1154,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() {
@@ -1204,14 +1239,55 @@ async function runNoteCommand(repo, opts) {
             // Then the files the note names, then the ones the session only read.
             touches: [...new Set([...t.touches, ...mentionedFiles(t.dir, body), ...(t.read ?? [])])].slice(0, 10),
         }));
+    // A touch is a file git tracks or one this session edited: never a file
+    // that was just lying around (a token, a scratch file).
+    const real = (dir, files) => {
+        const tracked = trackedFiles(dir, files.map((f) => f.split("#")[0]));
+        const edited = new Set((spent?.edited ?? []).map((f) => relative(dir, f).split("\\").join("/")));
+        return files.filter((f) => tracked.has(f.split("#")[0]) || edited.has(f.split("#")[0]));
+    };
+    for (const t of targets)
+        t.touches = real(t.dir, t.touches);
+    const scope = opts.personal ? "personal" : "repo";
+    const primary = targets[0];
+    const existing = listNotes(primary.dir, { branches: false });
+    let old;
+    if (opts.replaces) {
+        const want = basename(opts.replaces.trim());
+        old = findLearning(existing, want);
+        if (!old) {
+            console.error(`✗ --replaces: no learning named ${want} here. The names are the files in .trail/learnings/.`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    // What `replaces:` holds is the old learning's id (learning-fields.ts), not its file name.
+    const replaces = old?.id;
+    const text = `${opts.title}\n${body}`;
+    const gate = gateNote({
+        title: opts.title,
+        body,
+        personal: scope === "personal",
+        files: real(primary.dir, [...new Set([...mentionedFiles(primary.dir, text), ...(opts.touches ? primary.touches : [])])]),
+        namesSymbol: namesRepoSymbol(primary.dir, symbolCandidates(text)),
+        touches: primary.touches,
+        replaces,
+    }, liveLearnings(existing).filter((n) => (n.scope ?? "repo") === scope));
+    if (gate.problems.length && !opts.anyway) {
+        console.error("✗ not saved yet:");
+        for (const p of gate.problems)
+            console.error(`  · ${p}`);
+        console.error(`Fix it and run ${cmd("graft note")} again, or add --anyway if a check is wrong.`);
+        process.exitCode = 1;
+        return;
+    }
     const author = opts.author?.trim() || noteAuthor(repo);
     const date = new Date().toISOString().slice(0, 10);
-    const scope = opts.personal ? "personal" : "repo";
     const earlier = [];
     const saved = [];
     for (const t of targets) {
         earlier.push(...listNotes(t.dir));
-        saved.push(writeNote(t.dir, { title: opts.title, body, author, date, branch: currentBranch(t.dir), cost, touches: t.touches }, scope));
+        saved.push(writeNote(t.dir, { title: opts.title, body, author, date, branch: currentBranch(t.dir), cost, touches: t.touches, replaces }, scope));
     }
     const touches = targets.flatMap((t) => t.touches);
     track("note_saved", { has_cost: String(cost?.tokens !== undefined || cost?.minutes !== undefined), touches_bucket: countBucket(touches.length), scope: saved[0]?.scope ?? scope }, { repo });
@@ -1240,6 +1316,10 @@ async function runNoteCommand(repo, opts) {
         console.log(`· builds on ${prior.author ? `${prior.author}'s` : "a"} learning from ${shortDate(prior.date)}`);
     if (!SECTIONS.some((s) => sectionLead(body, s.heading) !== null))
         console.log("· tip: learnings read best under ## Decided, ## Tried and ruled out and ## Watch out");
+    for (const w of gate.warnings)
+        console.log(`· ${w}`);
+    if (old)
+        console.log(`· takes over from ${noteName(old)}, which stays as the record`);
     const repoSaved = saved.filter((n) => n.scope === "repo");
     if (repoSaved.length) {
         // Who else works on these files, for the case for committing it.
@@ -1247,7 +1327,8 @@ async function runNoteCommand(repo, opts) {
         console.log(`${lines.uncommitted} · git add ${repoSaved.map(notePlace).join(" ")}`);
         if (!process.stdout.isTTY && TRAIL)
             console.log(`[trail] Close your reply with one line, word for word. If this learning is committed by the end of your turn: ${lines.committed}\n` +
-                `  If it isn't: ${lines.uncommitted}`);
+                `  If it isn't: ${commitAsk(note.title, about)}\n` +
+                "  On a yes, commit it with the change: in the change's own commit when that isn't pushed yet.");
     }
     else {
         console.log("· just for you: kept on this machine, out of the repo");
@@ -1260,24 +1341,68 @@ async function runNoteCommand(repo, opts) {
     }
     printLines(cloudLines(repo, { command: "note" }));
 }
+/** What the agent asks after saving a team learning it hasn't committed: who reads it, and when. */
+export function commitAsk(title, about) {
+    const when = about ? `when they open ${basename(about.split("#")[0])}` : "on their next session here";
+    return `📝 Learning: "${title.replace(/"/g, "'")}" · your teammates' Claude reads it ${when}. Commit it with this change? (y/n)`;
+}
 /** Lines that close a command's output, with a blank line before them. */
 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);
@@ -1357,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
@@ -1383,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
@@ -1398,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);
@@ -1422,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))];
@@ -1438,23 +1613,30 @@ async function runInitCommand(dir, opts) {
             console.error(`✓ ${id.padEnd(width)}   ${summary}`.trimEnd());
         }
     }
-    // Under trail: what init learned from past sessions and PR reviews, where
-    // this repo's learnings are, and how many there already are.
+    // Under trail: what init learned, where this repo's learnings are, and how
+    // many there already are. The team's come from what is tied to the code:
+    // 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;
-    if (TRAIL && (pastRead || reviewRead)) {
+    let skillsWritten = [];
+    let teamSaved = 0;
+    const memory = TRAIL && wantClaude ? memoryCandidates(repo, { offered: offeredBefore(repo) }) : [];
+    if (TRAIL && (pastRead || reviewRead || memory.length)) {
         if (pastRead && !pastRead.done)
             console.error("· still reading your past sessions…");
         const fromSessions = pastRead ? (await pastRead.result).findings : [];
         if (reviewRead && !reviewRead.done)
             console.error("· still reading PR reviews…");
-        const fromReviews = reviewRead ? (await reviewRead.result).findings : [];
-        // On a terminal, the person ticks which to keep in one list for both
-        // sources, all ticked to start; a scripted run, or one with --yes, keeps
-        // them all. Cancelling saves none, and the next init asks again.
-        const picked = process.stdin.isTTY && process.stderr.isTTY && !opts.yes && fromSessions.length + fromReviews.length
+        const fromReviews = reviewRead ? anchoredReviews(repo, (await reviewRead.result).findings) : [];
+        // On a terminal, the person ticks which to keep in one list, the team's
+        // 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 && !pair && fromReviews.length + memory.length + fromSessions.length
             ? await pickLearnings([
-                ...fromSessions.map((f) => ({ title: f.title, forTeam: f.for === "team", sessions: f.sessions.length })),
-                ...fromReviews.map((f) => ({ title: f.title, forTeam: true, prs: f.prs.length })),
+                ...fromReviews.map((f) => ({ title: f.title, forTeam: true, prs: f.prs })),
+                ...memory.map((c) => ({ title: c.title, forTeam: c.forTeam, memory: true })),
+                ...fromSessions.map((f) => ({ title: f.title, forTeam: false, sessions: f.sessions.length })),
             ])
             : undefined;
         // The picked rows that are `found`'s, which start at `from` in the list.
@@ -1462,65 +1644,101 @@ 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 = [];
-        if (pastRead) {
-            const { result, saved, kept, cancelled } = await finishPastRead(repo, pastRead, keepFrom(0));
-            const offered = result.findings.length;
+        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"}`;
-                console.error(`✓ ${what} you told Claude more than once, from your last ${result.read} sessions here`);
-                // Each with how many sessions it was said in: saveFindings keeps the findings' order.
-                saved.forEach((note, i) => {
-                    const said = kept[i]?.sessions.length ?? 0;
-                    const count = said > 1 ? `told Claude in ${said} sessions: ` : "";
-                    console.error(`    ${note.scope === "personal" ? "just for you " : "for your team"} · ${count}${note.title}`);
-                });
+                console.error(`✓ ${what} reviewers made authors change, from the last ${result.prs} merged PRs here`);
+                // saveReviewFindings keeps the findings' order.
+                saved.forEach((note, i) => console.error(`    for your team · from review on ${(kept[i]?.prs ?? []).map((n) => `#${n}`).join(", ")}: ${note.title}`));
             }
             else if (cancelled) {
-                console.error(`· saved none of the ${offered} things you told Claude more than once; ${cmd("graft init")} again asks again`);
+                console.error(`· saved none of the ${offered} things reviewers made authors change; ${cmd("graft init")} again asks again`);
             }
             else if (offered) {
-                console.error(`· kept none of the ${offered} things you told Claude more than once`);
+                console.error(`· kept none of the ${offered} things reviewers made authors change`);
             }
             else if (result.reason === "failed") {
-                console.error(`· couldn't read your past sessions this time; ${cmd("graft init")} again tries again`);
+                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 (reviewRead) {
-            const { result, saved, kept, cancelled } = await finishReviewRead(repo, reviewRead, keepFrom(fromSessions.length));
+        if (memory.length) {
+            const { saved, cancelled } = await finishMemoryRead(repo, memory, keepFrom(fromReviews.length));
+            if (saved.length) {
+                console.error(`✓ kept ${saved.length} of the ${memory.length} notes your Claude keeps about this repo`);
+                for (const note of saved)
+                    console.error(`    ${note.scope === "personal" ? "just for you " : "for your team"} · ${note.title}`);
+            }
+            else if (cancelled) {
+                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, 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;
                 const what = n < offered ? `kept ${n} of the ${offered} things` : `learned ${n} thing${n === 1 ? "" : "s"}`;
-                console.error(`✓ ${what} reviewers flagged on more than one PR, from the last ${result.prs} merged PRs here`);
-                // saveReviewFindings keeps the findings' order.
-                saved.forEach((note, i) => console.error(`    for your team · flagged in review on ${kept[i]?.prs.length ?? 2} PRs: ${note.title}`));
+                console.error(`✓ ${what} you told Claude more than once, from your last ${result.read} sessions here, just for you`);
+                // Each with how many sessions it was said in: saveFindings keeps the findings' order.
+                saved.forEach((note, i) => {
+                    const said = kept[i]?.sessions.length ?? 0;
+                    const count = said > 1 ? `told Claude in ${said} sessions: ` : "";
+                    console.error(`    just for you  · ${count}${note.title}`);
+                });
             }
             else if (cancelled) {
-                console.error(`· saved none of the ${offered} things reviewers flagged; ${cmd("graft init")} again asks again`);
+                console.error(`· saved none of the ${offered} things you told Claude more than once; ${cmd("graft init")} again asks again`);
             }
             else if (offered) {
-                console.error(`· kept none of the ${offered} things reviewers flagged`);
+                console.error(`· kept none of the ${offered} things you told Claude more than once`);
             }
             else if (result.reason === "failed") {
-                console.error(`· couldn't read PR reviews this time; ${cmd("graft init")} again tries again`);
+                console.error(`· couldn't read your past sessions this time; ${cmd("graft init")} again tries again`);
             }
             learned.push(...saved);
         }
         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 (learned.some((s) => s.scope === "repo"))
+            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) {
             const learnings = listNotes(repo, { branches: false }).filter((n) => n.scope === "repo");
             if (learnings.length === 0)
-                console.error(`✓ learnings  ${LEARNINGS_DIR}/ · sessions that take real digging leave one there, for your whole team`);
+                console.error(`✓ learnings  ${LEARNINGS_DIR}/ · a session that fixes a bug, takes a correction or opens a PR leaves one there, for your whole team`);
             else
                 console.error(`✓ learnings  ${learnings.length} in ${LEARNINGS_DIR}/, from ${new Set(learnings.map((n) => n.author || "someone")).size} ${new Set(learnings.map((n) => n.author)).size === 1 ? "person" : "people"}`);
         }
@@ -1571,10 +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.
+    // 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;
@@ -1736,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(/\/+$/, "");
@@ -1776,6 +2114,7 @@ function logoutCommand(name = "logout") {
         .action(() => {
         const cloud = readCloud();
         clearPending();
+        removeBrainsServer(homedir());
         if (!clearCloud()) {
             console.error("· not connected to a workspace");
             return;
@@ -2157,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");