@100xprompt/brain 0.1.4 → 0.1.6

package/src/session/ops.ts

@@ -0,0 +1,111 @@
+// Listing, finding, reading and moving sessions, for `brain session ...` and for brain's background service (a move asked
+// from the dashboard, docs/sessions-contract.md). Nothing here prints or exits: callers say what happened.
+import { resolve } from "node:path"
+import type { SessionRef, Way, WriteResult } from "../adapters/types.ts"
+import { toolLabel } from "../brief.ts"
+import { prepare, sessionTokens } from "../memory/prepare.ts"
+import type { Session } from "./types.ts"
+
+// Adapters load only for what uses them: every tool's session-start hook runs cli.ts, and one adapter failing to load
+// (or loading slowly) must not hold up or break a session in another tool.
+let loaded: typeof import("../adapters/index.ts") | undefined
+export const loadAdapters = async () => (loaded ??= await import("../adapters/index.ts"))
+
+/** Every session brain can read under `home` (one tool's with `tool`), newest first, and the tools it could not list. */
+export async function listSessions(home: string, tool?: string): Promise<{ refs: SessionRef[]; errors: string[] }> {
+  const { READERS } = await loadAdapters()
+  const readers = tool ? READERS.filter((r) => r.tool === tool) : READERS
+  const errors: string[] = []
+  const lists = await Promise.all(
+    readers.map(async (r) => {
+      try {
+        return await r.list(home)
+      } catch (e) {
+        errors.push(`${r.tool}: ${(e as Error).message}`)
+        return []
+      }
+    }),
+  )
+  return { refs: lists.flat().sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "")), errors }
+}
+
+/** Whether a Claude Desktop session's transcripts (the current one or an earlier one) include Claude Code transcript `id`. */
+export const desktopHolds = (r: SessionRef, id: string) =>
+  r.extra?.cliSessionId === id || (Array.isArray(r.extra?.priorCliSessionIds) && (r.extra.priorCliSessionIds as unknown[]).includes(id))
+
+/** A session by `<tool>:<id>` (as `brain session list` prints it) or a unique start of its id. */
+export async function findSession(home: string, given: string): Promise<{ ref: SessionRef } | { error: string }> {
+  // An id copied from an older, shortened list ends in "…": what comes before it is still a unique start.
+  const id = given.replace(/…$/, "")
+  const { readerFor } = await loadAdapters()
+  const colon = id.indexOf(":")
+  const tool = colon > 0 && readerFor(id.slice(0, colon)) ? id.slice(0, colon) : undefined
+  const want = tool ? id.slice(colon + 1) : id
+  if (!want) return { error: `no session "${id}"; see \`brain session list\`` }
+  const { refs } = await listSessions(home, tool)
+  const exact = refs.filter((r) => r.sourceId === want)
+  const matches = exact.length ? exact : refs.filter((r) => r.sourceId.startsWith(want))
+  if (!matches.length && (!tool || tool === "claude-code")) {
+    // A Claude Code transcript Claude Desktop keeps a record of (its current one or an earlier one) is listed as its Claude
+    // Desktop session (an id from before).
+    const desk = (await listSessions(home, "claude-desktop")).refs.find((r) => desktopHolds(r, want))
+    if (desk) return { ref: desk }
+  }
+  if (!matches.length && (!tool || tool === "codex")) {
+    // A Codex thread the Codex app started is listed as Codex Desktop's (an id from before).
+    const desk = (await listSessions(home, "codex-desktop")).refs.find((r) => r.sourceId === want)
+    if (desk) return { ref: desk }
+  }
+  if (!matches.length) return { error: `no session "${id}"; see \`brain session list\`` }
+  if (matches.length > 1) return { error: `"${id}" matches ${matches.length} sessions (${matches.slice(0, 4).map((r) => `${r.tool}:${r.sourceId}`).join(", ")}…); give more of the id` }
+  return { ref: matches[0]! }
+}
+
+export async function readSession(home: string, ref: SessionRef): Promise<Session> {
+  const { readerFor } = await loadAdapters()
+  return readerFor(ref.tool)!.read(ref, home)
+}
+
+export interface MoveOptions {
+  way?: Way
+  cwd?: string
+  dryRun: boolean
+  lean?: boolean
+  noMemory?: boolean
+  budget?: number
+  tidy?: false
+}
+
+export type MoveOutcome =
+  | { ok: true; result: WriteResult; notes: string[]; skipped: string[] }
+  | { ok: false; why: string; notes: string[]; skipped: string[] }
+
+/**
+ * `source` continued in `target`: the first of its ways that is ready (or `way`), the session prepared as `brain session
+ * continue` prepares it (lean, memory, budget), written, and the move logged for the dashboard. Opens nothing.
+ */
+export async function moveSession(home: string, source: Session, target: string, opts: MoveOptions): Promise<MoveOutcome> {
+  const { writersFor, readerFor } = await loadAdapters()
+  const candidates = writersFor(target).filter((w) => !opts.way || w.way === opts.way)
+  if (!candidates.length) return { ok: false, why: `can't continue in "${target}"${opts.way ? ` by ${opts.way}` : ""}; see \`brain session targets\``, notes: [], skipped: [] }
+  const cwd = resolve(opts.cwd ?? source.header.project.cwd ?? process.cwd())
+  const prepared = await prepare(source, { home, cwd, dryRun: opts.dryRun, ...(opts.lean !== undefined ? { lean: opts.lean } : {}), ...(opts.noMemory ? { noMemory: true } : {}), ...(opts.budget ? { budget: opts.budget } : {}), ...(opts.tidy === false ? { tidy: false } : {}) })
+  const wopts = { home, cwd, dryRun: opts.dryRun, brief: prepared.brief }
+  const skipped: string[] = []
+  for (const w of candidates) {
+    const ready = await w.ready(wopts)
+    if (!ready.ok) {
+      skipped.push(`${w.way}: ${ready.why}`)
+      continue
+    }
+    const r = await w.write(prepared.session, wopts)
+    if (!r.dryRun) {
+      // The dashboard's conversion log: tools, way, title, project folder name and sizes; never the chat (src/dashboard/conversions.ts).
+      const { logConversion } = await import("../dashboard/conversions.ts")
+      const to = r.tool === "cursor" ? "cursor-ide" : r.tool
+      logConversion(home, { from: source.header.tool, fromLabel: readerFor(source.header.tool)?.label ?? toolLabel(source.header.tool), to: r.tool, toLabel: readerFor(to)?.label ?? w.label, way: r.way, title: source.header.title, cwd: source.header.project.cwd ?? cwd, turns: source.turns.length, tokens: sessionTokens(prepared.session), lean: prepared.lean })
+    }
+    return { ok: true, result: r, notes: prepared.notes, skipped }
+  }
+  return { ok: false, why: `no way to continue in "${target}" right now: ${skipped.join("; ")}`, notes: prepared.notes, skipped }
+}

package/src/settings/account.ts

@@ -18,7 +18,7 @@ import { gatewayUrl, safeUrl } from "../dashboard/send.ts"
 import { brainDir, MACHINE_TOKEN, machineId, machineKeyPath, readMachineToken } from "../dashboard/state.ts"
 import { readOrgConfig } from "../org/config.ts"
 import { type Row, reconcile } from "./apply.ts"
-import { checkValue, parseId } from "./catalog.ts"
+import { checkValue, parseId, resolve } from "./catalog.ts"
 import { type Entry, type Level, readSettingsFile, same, type SettingsDoc, type Source, updateDoc, type Value } from "./store.ts"
 import { memoryOn } from "./values.ts"
 
@@ -40,14 +40,16 @@ export function forgetMachineToken(home: string): boolean {
 /**
  * A computer the account knows afresh (paired again after "Remove this machine", or a copied ~/.brain paired as a computer
  * of its own) has an empty document there: every value set at this computer's level here is sent again, and the next fetch
- * starts from nothing, so the account's empty document never erases them.
+ * starts from nothing, so the account's empty document never erases them. Not the dashboard's or an admin's: those are the
+ * account's to keep (a computer never sends them as its own; the gateway refuses that), and an account that forgot this
+ * computer forgot them too.
  */
 export function sendAllAgain(home: string): void {
   updateDoc(home, (d) => {
     const at = new Date().toISOString()
     for (const [id, e] of Object.entries(d.levels.computer)) {
       const ref = parseId(id)
-      if ("error" in ref || ref.family.remote !== "yes") continue
+      if ("error" in ref || ref.family.remote !== "yes" || !COMPUTER_SOURCES.includes(e.source)) continue
       d.outbox = d.outbox.filter((c) => !(c.id === id && c.level === "computer"))
       d.outbox.push({ id, level: "computer", value: e.value, source: e.source, at: e.at || at, ...(e.command ? { command: e.command } : {}) })
     }
@@ -73,6 +75,8 @@ export interface Exchange {
 
 const LEVEL_OUT: Record<"computer" | "person", "machine" | "account"> = { computer: "machine", person: "account" }
 const SOURCES: Source[] = ["settings", "command", "dashboard", "admin", "local-page"]
+/** The sources a computer sends its changes with; the dashboard's and an admin's come only from the account. */
+const COMPUTER_SOURCES: Source[] = ["settings", "command", "local-page"]
 const isValue = (v: unknown): v is Value => typeof v === "boolean" || (typeof v === "number" && Number.isFinite(v)) || typeof v === "string"
 const obj = (v: unknown): Record<string, any> => (v && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, any>) : {})
 const isObj = (v: unknown) => !!v && typeof v === "object" && !Array.isArray(v)
@@ -87,6 +91,9 @@ function entryFrom(id: string, level: Level, e: unknown): Entry | undefined {
   return { value: x.value, source: SOURCES.includes(x.source) ? x.source : "dashboard", at: x.at, ...(Number.isSafeInteger(x.rev) ? { rev: x.rev } : {}) }
 }
 
+const sameEntry = (x: Entry | undefined, y: Entry | undefined) =>
+  x === y || (!!x && !!y && same(x.value, y.value) && x.source === y.source && x.at === y.at && x.rev === y.rev)
+
 /** "<machine>.<account>" as two numbers; undefined when it is not one. */
 const revParts = (r: unknown): [number, number] | undefined => {
   const m = typeof r === "string" ? /^(\d{1,15})\.(\d{1,15})$/.exec(r) : null
@@ -120,8 +127,6 @@ export async function exchange(home: string, o: { env?: Env; fetchImpl?: typeof
   if (file.problem) return { ...out, why: file.problem === "newer" ? "settings.json was written by a newer brain: update brain to exchange settings here" : "settings.json could not be read: `brain settings set` writes a new one" }
   const base = gatewayUrl(home)
   if (!safeUrl(`${base}/api/brain/settings`)) return { ...out, why: `the gateway address ${base} is not https; the token is never sent over it` }
-  // A computer the account knows afresh: everything set here goes again (see sendAllAgain).
-  if (file.doc.sync.machine !== machine) sendAllAgain(home)
   const deadline = Date.now() + (o.timeoutMs ?? 3_000)
   const call = async (method: string, path: string, body?: unknown): Promise<{ status: number; json: unknown }> => {
     const left = deadline - Date.now()
@@ -162,6 +167,14 @@ export async function exchange(home: string, o: { env?: Env; fetchImpl?: typeof
   }
 
   try {
+    // A computer the account knows afresh: everything set here goes again (see sendAllAgain).
+    if (file.doc.sync.machine !== machine) sendAllAgain(home)
+    // A change this computer cannot send as its own (an older brain queued the dashboard's) would wait for good and keep
+    // the account's value from being taken: it leaves the outbox.
+    if (readSettingsFile(home).doc.outbox.some((c) => !COMPUTER_SOURCES.includes(c.source)))
+      updateDoc(home, (d) => {
+        d.outbox = d.outbox.filter((c) => COMPUTER_SOURCES.includes(c.source))
+      })
     // 1. Send what changed here.
     const snapshot = readSettingsFile(home).doc.outbox
     for (const level of ["computer", "person"] as const) {
@@ -220,6 +233,10 @@ export async function exchange(home: string, o: { env?: Env; fetchImpl?: typeof
         const stored = revParts(d.sync.rev)
         if (stored && (fetched[0] < stored[0] || fetched[1] < stored[1])) return
         const pending = new Set(d.outbox.map((c) => `${c.level}\0${c.id}`))
+        // The levels as they were, to tell what taking the answer changes in the value in force here.
+        const before: SettingsDoc = { ...d, levels: { ...d.levels } }
+        // The same value written again on the account (a newer rev at another time: the dashboard's "try again").
+        const again: string[] = []
         const next: Record<"computer" | "person", Record<string, Entry>> = { computer: {}, person: {} }
         for (const [level, srv] of [
           ["computer", j.machine.entries],
@@ -235,8 +252,14 @@ export async function exchange(home: string, o: { env?: Env; fetchImpl?: typeof
             const e = entryFrom(id, level, raw)
             if (!e) continue
             const was = d.levels[level][id]
-            // The same value from the same source: kept as it is here (with the command that set it).
-            next[level][id] = was && same(was.value, e.value) && was.source === e.source ? { ...was, ...(e.rev !== undefined ? { rev: e.rev } : {}) } : e
+            if (was && same(was.value, e.value) && was.source === e.source) {
+              if (e.rev !== undefined && was.rev !== undefined && e.rev > was.rev && e.at !== was.at) {
+                next[level][id] = { ...e, ...(was.command ? { command: was.command } : {}) }
+                again.push(id)
+              }
+              // The same value from the same source: kept as it is here (with the command that set it).
+              else next[level][id] = { ...was, ...(e.rev !== undefined ? { rev: e.rev } : {}) }
+            } else next[level][id] = e
           }
         }
         // Memory turned on from afar on a computer that sends it to a team server: only this computer turns that on. Judged
@@ -275,6 +298,20 @@ export async function exchange(home: string, o: { env?: Env; fetchImpl?: typeof
         const locks: SettingsDoc["locks"] = {}
         for (const [id, l] of Object.entries(obj(j.locks))) if (Object.hasOwn(obj(j.locks), id) && isValue(obj(l).value) && !("error" in parseId(id))) locks[id] = { value: obj(l).value }
         d.locks = locks
+        // The value in force here set from the account (set, set again, the same value from another source, or cleared down
+        // to another level's equal value) is applied afresh, even where it failed or was changed by hand since: that is the
+        // person setting it (again). A change at a level that does not decide here applies nothing.
+        // A setting with nothing to apply set again is still taken, so what it gave is said (below, after applying).
+        for (const id of new Set([...out.received, ...again])) {
+          const ref = parseId(id)
+          if ("error" in ref) continue
+          const a = resolve(d, ref)
+          if (a.value === undefined || (a.from !== "computer" && a.from !== "person" && a.from !== "team")) continue
+          const b = resolve(before, ref)
+          if (b.from === a.from && sameEntry(b.entry, a.entry)) continue
+          if (ref.family.apply) delete d.applied[id]
+          if (!out.received.includes(id)) out.received.push(id)
+        }
         d.history = d.history.slice(-200)
         d.sync.rev = `${fetched[0]}.${fetched[1]}`
         d.sync.lastSyncAt = now
@@ -295,13 +332,31 @@ export async function exchange(home: string, o: { env?: Env; fetchImpl?: typeof
 
   // 4. Apply what changed, and say what it gave (a value held back here counts as failed).
   if (o.apply !== false) {
+    let elsewhere: string[] = []
     try {
-      out.applied = (await reconcile(home, { env: o.env ?? process.env })).applied
+      const r = await reconcile(home, { env: o.env ?? process.env })
+      out.applied = r.applied
+      elsewhere = r.elsewhere
     } catch {}
     const applied: Record<string, unknown> = {}
+    const at = new Date().toISOString()
     for (const row of out.applied)
-      applied[row.id] = { want: row.value ?? null, ok: row.state !== "failed" && row.state !== "not on this computer" && row.state !== "can't read", ...(row.error ? { error: row.error } : {}), ...(row.notes.length ? { notes: row.notes.slice(0, 5) } : {}), at: new Date().toISOString() }
-    for (const h of out.held) applied[h.id] = { want: true, ok: false, error: h.why, at: new Date().toISOString() }
+      applied[row.id] = { want: row.value ?? null, ok: row.state !== "failed" && row.state !== "not on this computer" && row.state !== "can't read", ...(row.error ? { error: row.error } : {}), ...(row.notes.length ? { notes: row.notes.slice(0, 5) } : {}), at }
+    // A value taken that has nothing to apply (brain reads it where it is used: lean.*, memory.enabled) is in force once
+    // taken; one for a tool not on this computer waits for that tool. Both are said, so the dashboard never waits on them.
+    // (A value in force set from the account is applied afresh above, so it is among the applied rows.)
+    if (out.received.length) {
+      const doc = readSettingsFile(home).doc
+      for (const id of out.received) {
+        const ref = parseId(id)
+        if ("error" in ref || Object.hasOwn(applied, id) || out.held.some((h) => h.id === id)) continue
+        const want = resolve(doc, ref).value
+        if (want === undefined) continue
+        if (!ref.family.apply) applied[id] = { want, ok: true, at }
+        else if (elsewhere.includes(id)) applied[id] = { want, ok: false, error: `${ref.tool ?? "this tool"} is not on this computer: brain applies it once it is`, at }
+      }
+    }
+    for (const h of out.held) applied[h.id] = { want: true, ok: false, error: h.why, at }
     if (Object.keys(applied).length && Date.now() < deadline) {
       try {
         await call("POST", "/api/brain/settings/applied", { machine, applied })

package/src/settings/catalog.ts

@@ -168,7 +168,7 @@ async function reconnect(ctx: Ctx, tool: string, change: { model?: string; conte
   if (cs.state === "not-connected") return { ok: true }
   if (!cs.settings) return { ok: false, error: olderBrain(tool) }
   if (!hasKey(ctx.home)) return { ok: false, error: "not signed in to the gateway (brain gateway login)" }
-  const r = await connect(ctx.home, tool, { settings: connectSettings(ctx, tool, change), probe: false, env: ctx.env })
+  const r = await connect(ctx.home, tool, { settings: connectSettings(ctx, tool, change), probe: false, env: ctx.env, keepTheirs: { for: change.model !== undefined ? "model" : "contextEdit" } })
   return r.ok ? { ok: true, notes: notesOf(r.lines, ctx.home, /^warning: /) } : { ok: false, error: cleanText(r.lines.join("; "), ctx.home) }
 }
 
@@ -397,7 +397,25 @@ const reports: Family = {
   },
 }
 
-export const FAMILIES: Family[] = [gateway, model, contextEdit, mcp, hooks, leanAuto, leanThreshold, leanMinChars, memoryEnabled, reports]
+// Only this computer decides whether the website may move its sessions, and whether its session list leaves it.
+const movesFromDashboard = internal("moves.fromDashboard", {
+  label: "Moves from the dashboard",
+  help: "A session move asked from your dashboard: ask (this computer asks you first), allow (it runs), or off (it is refused).",
+  type: { kind: "choice", choices: ["ask", "allow", "off"] },
+  levels: ["computer"],
+  remote: "no",
+  team: "none",
+})
+const reportsSessions = internal("reports.sessions", {
+  label: "Session list to your account",
+  help: "This computer sends its session list (titles and project folder names; never chat text) so the dashboard can list and move sessions.",
+  type: { kind: "bool" },
+  levels: ["computer"],
+  remote: "no",
+  team: "none",
+})
+
+export const FAMILIES: Family[] = [gateway, model, contextEdit, mcp, hooks, leanAuto, leanThreshold, leanMinChars, memoryEnabled, reports, reportsSessions, movesFromDashboard]
 
 // ---- ids and values -----------------------------------------------------------------------------------------------------
 

package/src/settings/cli.ts

@@ -173,6 +173,9 @@ async function withAccount(home: string, env: Env, say: (l: string) => void, fet
   return x
 }
 
+/** An exchange that took or applied something changed what the report says (a cleared value shows only there). */
+export const tookSomething = (x: Exchange | undefined) => !!x?.ok && (x.received.length > 0 || x.applied.length > 0)
+
 /**
  * `brain settings ...`. `hooks.changed` is called when a set or unset saved something (the dashboard report is sent then,
  * not after a refusal). A paired computer exchanges with the account first (and, after a change, again).
@@ -195,7 +198,7 @@ export async function settingsCommand(
   if (file.problem === "damaged") note(`note: ${settingsFile(home)} could not be read: brain's defaults apply (memory counts as off), and it is kept aside on the next change`)
   // What the account changed is taken (and applied) before anything is shown or changed here; the whole command keeps to 3 s.
   const deadline = Date.now() + 3_000
-  if (["list", "get", "history", "set", "unset"].includes(sub) && !file.problem) await withAccount(home, env, note, hooks.fetchImpl, deadline)
+  if (["list", "get", "history", "set", "unset"].includes(sub) && !file.problem && tookSomething(await withAccount(home, env, note, hooks.fetchImpl, deadline))) hooks.changed?.()
   switch (sub) {
     case "list": {
       const ti = rest.indexOf("--tool")
@@ -262,7 +265,7 @@ export async function settingsCommand(
       if (o.change) hooks.changed?.()
       const code = printOutcome(o, io, sub === "set" ? "saved" : "cleared")
       // The change goes to the account at once.
-      if (o.change) await withAccount(home, env, io.out, hooks.fetchImpl, deadline)
+      if (o.change && tookSomething(await withAccount(home, env, io.out, hooks.fetchImpl, deadline))) hooks.changed?.()
       return code
     }
     case "history": {
@@ -319,8 +322,10 @@ const productName = (alias: unknown) => (typeof alias === "string" && MODEL_ALIA
  * `brain status`: this computer at a glance, with whether its settings are applied. On a paired computer it first exchanges
  * with the account (so a change made in the dashboard is taken and applied); otherwise it only reads.
  */
-export async function statusCommand(home: string, io: Io = { out: (l) => console.log(l) }, env: Env = process.env, deps: { fetchImpl?: typeof fetch } = {}): Promise<number> {
+export async function statusCommand(home: string, io: Io = { out: (l) => console.log(l) }, env: Env = process.env, deps: { fetchImpl?: typeof fetch; changed?: () => void } = {}): Promise<number> {
   const exchanged = readSettingsFile(home).problem ? undefined : await exchange(home, { env, ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}) })
+  // What it took from the account goes to the dashboard in a report too (the computer may have no background service).
+  if (tookSomething(exchanged)) deps.changed?.()
   const { VERSION } = await import("../self.ts")
   const { machineName, gatewayState } = await import("../dashboard/report.ts")
   const { machineId, readCache } = await import("../dashboard/state.ts")
@@ -392,6 +397,13 @@ export async function statusCommand(home: string, io: Io = { out: (l) => console
   for (const h of acct.held) io.out(`  ${h.id}: not taken from your account: ${h.why}`)
   const refused = acct.refused.slice(-3)
   if (refused.length) io.out(`  refused by your account (this computer went back to its value): ${refused.map((r) => `${r.id} = ${String(r.value)} (${r.message || r.code})`).join("; ")}`)
+  const { serviceStatusLines } = await import("../service.ts")
+  if (acct.paired) serviceStatusLines(home).forEach((l) => io.out(l))
+  if (acct.paired) {
+    const { movesState } = await import("../moves.ts")
+    const mv = movesState(home)
+    if (mv.waiting) io.out(`moves from the dashboard: ${mv.waiting} wait${mv.waiting === 1 ? "s" : ""} for you here (brain moves)`)
+  }
   const recorded = readRecordedEnv(home)
   // As the code that obeys them reads them: BRAIN_NO_REPORT anything but empty, 0 or false; BRAIN_NO_MEMORY exactly 1.
   const envOff = [...(off && /BRAIN_NO_REPORT/.test(off) ? ["BRAIN_NO_REPORT"] : []), ...(env.BRAIN_NO_MEMORY === "1" ? ["BRAIN_NO_MEMORY"] : [])]
@@ -432,6 +444,9 @@ export async function syncCommand(home: string, io: Io = { out: (l) => console.l
   else {
     noticeOnce(home, io.out)
     const { buildReport } = await import("../dashboard/report.ts")
+    const { sendSessions } = await import("../dashboard/sessions.ts")
+    const listSent = await sendSessions(home, { env, force: true, ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}) })
+    if (listSent.sent) io.out(`sessions: sent this computer's list (${listSent.total}) for the dashboard`)
     const sent = await sendReport(home, await buildReport(home, { env }), { timeoutMs: 5_000, ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}) })
     io.out(sent.ok ? `report: sent to ${gatewayUrl(home)}` : `report: not sent (${sent.why})`)
   }

package/src/settings/env.ts

@@ -95,6 +95,8 @@ export function isPersonsCommand(argv: string[]): boolean {
   // The session hook (run by a tool), the MCP server (started by a tool), and the background children brain starts.
   if (cmd === "hook" || (cmd === "session" && rest[0] === "hook")) return false
   if (cmd === "mcp" && rest[0] === "serve") return false
+  // The background service is started by launchd or systemd, with the environment it was given, not the person's shell.
+  if (cmd === "service" && rest[0] === "run") return false
   if (cmd === "dashboard" && rest[0] === "push" && (rest.includes("--quiet") || rest.includes("--at"))) return false
   if (cmd === "memory" && rest[0] === "sync" && rest.includes("--quiet")) return false
   return true

package/src/settings/pair.ts

@@ -79,5 +79,8 @@ export async function pairCommand(args: string[], home: string, io: Io = { out:
   io.out(`paired${had ? " again" : ""}: ${machineName()} is linked to your 100xprompt account; its token is in ~/.brain/machine.key (readable only by you).`)
   io.out(x.ok ? `settings: ${x.sent} change${x.sent === 1 ? "" : "s"} made here sent to your account; the dashboard's Brain view shows this computer's settings.` : `settings: not exchanged yet (${x.why}); \`brain sync\` tries again.`)
   if (x.ok) for (const l of exchangeLines({ ...x, sent: 0 }, 0)) io.out(l)
+  const { serviceState } = await import("../service.ts")
+  // macOS and Linux only for now; elsewhere `brain sync` takes the dashboard's changes.
+  if ((process.platform === "darwin" || process.platform === "linux") && !serviceState(home).installed) io.out("next: `brain service install` runs brain in the background, so changes you make in the dashboard apply here by themselves.")
   return 0
 }

package/src/settings/values.ts

@@ -12,15 +12,22 @@ export const LIMITS = {
   "lean.minChars": { min: 300, max: 100_000 },
 } as const
 
+/** Whether a session move asked from the dashboard runs here: ask the person first, run it, or refuse it. */
+export const MOVES_CHOICES = ["ask", "allow", "off"] as const
+export type MovesSetting = (typeof MOVES_CHOICES)[number]
+
 export const DEFAULTS: Record<string, Value> = {
   "lean.auto": LEAN_DEFAULTS.auto,
   "lean.threshold": LEAN_DEFAULTS.threshold,
   "lean.minChars": LEAN_DEFAULTS.minChars,
   "memory.enabled": true,
+  "moves.fromDashboard": "ask",
+  "reports.sessions": true,
 }
 
 /** Whether a value is a valid one for this setting (a hand-edited or newer file may hold anything). */
 export function validValue(id: string, v: Value): boolean {
+  if (id === "moves.fromDashboard") return typeof v === "string" && (MOVES_CHOICES as readonly string[]).includes(v)
   if (typeof DEFAULTS[id] === "boolean") return typeof v === "boolean"
   const lim = LIMITS[id as keyof typeof LIMITS]
   return typeof v === "number" && Number.isInteger(v) && (!lim || (v >= lim.min && v <= lim.max))
@@ -55,6 +62,27 @@ export function memoryOn(home: string, d?: SettingsDoc): boolean {
   return r.problem === "damaged" ? false : (valueOf(r.doc, "memory.enabled") as boolean)
 }
 
+/** A setting only this computer can have: its own level counts, nothing set from elsewhere or by a team. */
+const localValue = (d: SettingsDoc, id: string): Value => {
+  const e = d.levels.computer[id]
+  return e && validValue(id, e.value) ? e.value : DEFAULTS[id]!
+}
+
+/** Whether moves asked from the dashboard run here (`brain settings set moves.fromDashboard ask|allow|off`; ask by default). */
+export function movesSetting(home: string, d?: SettingsDoc): MovesSetting {
+  if (d) return localValue(d, "moves.fromDashboard") as MovesSetting
+  const r = readSettingsFile(home)
+  // A file that cannot be read gives no permission: the person is asked.
+  return r.problem === "damaged" ? "ask" : (localValue(r.doc, "moves.fromDashboard") as MovesSetting)
+}
+
+/** Whether this computer sends its session list (titles, project folder names) to the account; on by default. */
+export function sessionsListOn(home: string, d?: SettingsDoc): boolean {
+  if (d) return localValue(d, "reports.sessions") as boolean
+  const r = readSettingsFile(home)
+  return r.problem === "damaged" ? false : (localValue(r.doc, "reports.sessions") as boolean)
+}
+
 /** What brain says where memory would have been used. */
 export const MEMORY_OFF = "memory is turned off on this computer (`brain settings set memory.enabled on` turns it on)"