@100xprompt/brain 0.1.5 → 0.1.6

package/src/adapters/codex/reader.ts

@@ -7,7 +7,7 @@ import { clip, header, iso, lossCounter, noteModel, toolKindOf } from "../../ses
 import { withSnapshot } from "../../sqlite.ts"
 import type { Reader, SessionRef } from "../types.ts"
 import { summaryBody } from "./native.ts"
-import { IMPORT_MARKER, LABEL, TOOL, idFromName, isContext, isImageLabel, isRolloutName, outputText, patchFiles } from "./records.ts"
+import { IMPORT_MARKER, LABEL, TOOL, idFromName, isContext, isImageLabel, isRolloutName, outputText, patchFiles, isDesktopOriginator } from "./records.ts"
 
 // Codex CLI sessions. Each thread is a rollout under ~/.codex/sessions/YYYY/MM/DD (archived ones under
 // archived_sessions/), one JSON record per line: {timestamp, ordinal?, type, payload}, starting with
@@ -658,6 +658,7 @@ function listOne(path: string, archived: boolean, index: Map<string, ThreadRow>)
   let id = idFromName(path)
   let cwd: string | undefined
   let version: string | undefined
+  let originator: string | undefined
   let title: string | undefined
   if (format === "json") {
     // Legacy sessions are small single files and the index never had them, so read the first request here.
@@ -674,6 +675,7 @@ function listOne(path: string, archived: boolean, index: Map<string, ThreadRow>)
         id = str(meta.payload?.id) ?? id
         cwd = str(meta.payload?.cwd)
         version = str(meta.payload?.cli_version)
+        originator = str(meta.payload?.originator)
       }
     } catch {
       // Listed from its file name; read() says what is wrong with it.
@@ -691,14 +693,16 @@ function listOne(path: string, archived: boolean, index: Map<string, ThreadRow>)
     ...(title ? { title } : {}),
     ...(cwd ? { cwd } : {}),
     ...(updatedAt ? { updatedAt } : {}),
-    extra: { format, archived, ...(version ? { version } : {}) },
+    extra: { format, archived, ...(version ? { version } : {}), ...(originator ? { originator } : {}) },
   }
 }
 
-export const codexReader: Reader = {
-  tool: TOOL,
-  label: LABEL,
+/** Every Codex rollout under ~/.codex (the CLI's and the desktop apps'), newest first. */
+export async function listRollouts(home: string): Promise<SessionRef[]> {
+  return codexReaderAll.list(home)
+}
 
+const codexReaderAll: Pick<Reader, "list"> = {
   async list(home) {
     const roots = [
       { dir: join(codexDir(home), "sessions"), archived: false },
@@ -714,6 +718,16 @@ export const codexReader: Reader = {
     }
     return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
   },
+}
+
+export const codexReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  /** The CLI's (and editors') sessions: the desktop apps' are listed as Codex Desktop's (codex-desktop). */
+  async list(home) {
+    return (await listRollouts(home)).filter((r) => !isDesktopOriginator(r.extra?.originator))
+  },
 
   async read(ref) {
     const path = ref.path

package/src/adapters/codex/records.ts

@@ -1,10 +1,27 @@
 // Facts about Codex rollout records shared by the reader and the writer. Checked against codex-rs at
 // rust-v0.147.0 (the version installed here) and the rollouts it wrote on this Mac; see
 // docs/sessions/2026-11-08-session-formats.md, entries 3 and 69.
+import { existsSync } from "node:fs"
 
 export const TOOL = "codex"
 export const LABEL = "Codex"
 
+/**
+ * Codex's desktop apps start their sessions through Codex's app-server, which stamps each with the app's name as its
+ * originator (Codex's own source: a first-party client's name starts with "Codex ", e.g. "Codex Desktop"; the ChatGPT
+ * app's is "codex_chatgpt_desktop", the work app's "codex_work_desktop"). Their sessions share ~/.codex with the CLI;
+ * brain lists them as Codex Desktop's. Case matters: Codex's own test client ("codex-app-server-client-test") is not an app.
+ */
+const DESKTOP_IDS = new Set(["codex_desktop", "codex_chatgpt_desktop", "codex_work_desktop"])
+export const isDesktopOriginator = (o: unknown): boolean => typeof o === "string" && (/^Codex .*\b(Desktop|App)\b/.test(o) || DESKTOP_IDS.has(o))
+export const DESKTOP_TOOL = "codex-desktop"
+export const DESKTOP_LABEL = "Codex Desktop"
+/** The Codex app is on this computer (macOS: Codex.app). */
+export function codexAppHere(home: string): boolean {
+  if (process.platform !== "darwin") return false
+  return existsSync("/Applications/Codex.app") || existsSync(`${home}/Applications/Codex.app`)
+}
+
 /** Codex versions whose rollout format the writer was checked against. */
 export const TESTED_VERSIONS = ["0.147.0"]
 

package/src/adapters/codex/writer.ts

@@ -88,7 +88,7 @@ export interface RolloutPlan {
 /** The rollout lines for `session` as a new Codex thread `id`. Pure: writes nothing. */
 export function planRollout(
   session: Session,
-  opts: { id: string; now: Date; cwd: string; cliVersion: string; modelProvider: string; git?: Omit<Project, "cwd">; newId?: () => string },
+  opts: { id: string; now: Date; cwd: string; cliVersion: string; modelProvider: string; git?: Omit<Project, "cwd">; newId?: () => string; originator?: string },
 ): RolloutPlan {
   const newId = opts.newId ?? (() => Bun.randomUUIDv7())
   const lines: RolloutPlan["lines"] = []
@@ -118,7 +118,7 @@ export function planRollout(
     session_id: opts.id,
     timestamp: opts.now.toISOString(),
     cwd,
-    originator: "codex-tui",
+    originator: opts.originator ?? "codex-tui",
     cli_version: opts.cliVersion,
     source: "cli",
     thread_source: "user",
@@ -414,13 +414,24 @@ export type Register = (codexHome: string, threadId: string, cwd: string, name?:
 /** The title the thread gets in Codex's picker: the session's own, marked with where it came from. */
 export const threadName = (session: Session) => `${plainTitle(session.header.title ?? firstUserText(session) ?? "Session")} (from ${toolLabel(session.header.tool)})`
 
-export function makeCodexWriter(register: Register = registerThread): Writer {
+/** For a desktop app's thread: who it is (originator), whether the app is here, and how the app opens it. */
+export interface CodexKind {
+  tool: string
+  label: string
+  originator: string
+  here(home: string): boolean
+  notHere: string
+  open(id: string, cwd: string, title: string): { open: string; note?: string }
+}
+
+export function makeCodexWriter(register: Register = registerThread, kind?: CodexKind): Writer {
   return {
-    tool: TOOL,
-    label: LABEL,
+    tool: kind?.tool ?? TOOL,
+    label: kind?.label ?? LABEL,
     way: "native",
 
     async ready(opts: WriteOptions): Promise<Readiness> {
+      if (kind && !kind.here(opts.home)) return { ok: false, why: kind.notHere }
       const v = codexVersion()
       if (!v) return { ok: false, why: "Codex is not installed here (`codex --version` failed)" }
       if (!TESTED_VERSIONS.includes(v))
@@ -440,6 +451,7 @@ export function makeCodexWriter(register: Register = registerThread): Writer {
         cliVersion: codexVersion() ?? TESTED_VERSIONS[0]!,
         modelProvider: configuredProvider(opts.home),
         git: gitInfo(cwd),
+        ...(kind ? { originator: kind.originator } : {}),
       })
       const path = rolloutPath(opts.home, id, now)
       const lost = [...plan.lost]
@@ -463,12 +475,13 @@ export function makeCodexWriter(register: Register = registerThread): Writer {
         if (!registered.ok) lost.push(`not in Codex's thread index (${registered.why}); it resumes by id, and appears in \`codex resume\` once opened`)
         else if (registered.named === false) lost.push("thread title (Codex refused the name; the picker shows the first message instead)")
       }
+      const opened = kind ? kind.open(id, cwd, threadName(session)) : { open: `cd ${shellQuote(cwd)} && codex resume ${id}` }
       return {
-        tool: TOOL,
+        tool: kind?.tool ?? TOOL,
         way: "native",
         sessionId: id,
         written: [path],
-        open: `cd ${shellQuote(cwd)} && codex resume ${id}`,
+        ...opened,
         lost,
         dryRun: !!opts.dryRun,
       }

package/src/adapters/codex-desktop/index.ts

@@ -0,0 +1,38 @@
+// Codex Desktop (OpenAI's Codex app): its threads are Codex rollouts under ~/.codex, shared with the CLI, that the app's
+// app-server stamped with the app's name as originator (codex/records.ts). Listed and read as the app's; continued into
+// the app as a native rollout stamped "Codex Desktop" (when the app is here and Codex's format is one brain knows), else
+// by the continuation brief. The app opens on its own threads.
+import { codexReader, listRollouts } from "../codex/reader.ts"
+import { codexAppHere, DESKTOP_LABEL, DESKTOP_TOOL, isDesktopOriginator } from "../codex/records.ts"
+import { makeCodexWriter } from "../codex/writer.ts"
+import { shellQuote } from "../../session/open.ts"
+import type { Reader, Writer } from "../types.ts"
+
+export const codexDesktopReader: Reader = {
+  tool: DESKTOP_TOOL,
+  label: DESKTOP_LABEL,
+  async list(home) {
+    return (await listRollouts(home)).filter((r) => isDesktopOriginator(r.extra?.originator)).map((r) => ({ ...r, tool: DESKTOP_TOOL }))
+  },
+  async read(ref, home) {
+    const s = await codexReader.read({ ...ref, tool: "codex" }, home)
+    s.header.tool = DESKTOP_TOOL
+    s.header.id = `${DESKTOP_TOOL}:${ref.sourceId}`
+    return s
+  },
+}
+
+export const codexDesktopWriter = makeCodexWriter(undefined, {
+  tool: DESKTOP_TOOL,
+  label: DESKTOP_LABEL,
+  originator: "Codex Desktop",
+  here: codexAppHere,
+  notHere: "the Codex app is not on this computer",
+  open: (id, cwd, title) => ({
+    open: process.platform === "darwin" ? "open -a Codex" : "the Codex app",
+    note: `then pick "${title.slice(0, 80)}" in its threads (or in a terminal: cd ${shellQuote(cwd)} && codex resume ${id})`,
+  }),
+})
+
+export const readers: Reader[] = [codexDesktopReader]
+export const writers: Writer[] = [codexDesktopWriter]

package/src/adapters/index.ts

@@ -1,6 +1,8 @@
 import type { Reader, Writer } from "./types.ts";
 import * as claudeCode from "./claude-code/index.ts";
+import * as claudeDesktop from "./claude-desktop/index.ts";
 import * as codex from "./codex/index.ts";
+import * as codexDesktop from "./codex-desktop/index.ts";
 import * as cursorIde from "./cursor-ide/index.ts";
 import * as cursorCli from "./cursor-cli/index.ts";
 import * as geminiCli from "./gemini-cli/index.ts";
@@ -47,7 +49,9 @@ import { briefWriter, briefWriters } from "../brief-writers.ts";
 // no native or import writer is still a target through the continuation brief (brief-writers.ts).
 const MODULES = [
   claudeCode,
+  claudeDesktop,
   codex,
+  codexDesktop,
   cursorIde,
   cursorCli,
   geminiCli,

package/src/cli.ts

@@ -14,10 +14,9 @@ import { countTurns, firstUserText, toJsonl, unpaired } from "./session/util.ts"
 // brain session: one working session, any AI coding tool.
 // Design: docs/sessions/2026-11-08-session-switcher.md.
 
-// Adapters load only for commands that use them: every tool's session-start hook runs this file, and
+// Adapters load only for commands that use them (src/session/ops.ts): every tool's session-start hook runs this file, 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
-const adapters = async () => (loaded ??= await import("./adapters/index.ts"))
+const adapters = async () => (await import("./session/ops.ts")).loadAdapters()
 
 const USAGE = `brain session <command>
 
@@ -28,6 +27,7 @@ const USAGE = `brain session <command>
   handoff --in <tool> [--from <tool>] [--dry-run] [--no-open]   the newest session in this folder, to <tool>
   continue/handoff also take  [--lean | --full] [--budget <tokens>] [--no-memory] [--no-tidy]   lean: big tool output becomes digests (automatic on long sessions); budget: mask in levels until the session fits
   targets                                             where a session can go, and how
+  open <id> [--print]                                 open a session again in its own tool, in its own folder
   hooks install|uninstall|status [--tool <id>] [--dry-run]    session-start hooks that deliver briefs
   hook <event> --tool <id>                            (run by a tool's hook; reads the hook's JSON on stdin)
 
@@ -46,6 +46,7 @@ brain settings [list|get|set|unset|history|ids]    brain's settings on this comp
 brain sync                                         exchange settings with your account, apply what changed or failed, and send this computer's report now
 brain pair [--no-browser] | status | forget        approve this computer in your 100xprompt account, so its settings show in the dashboard
 brain service install | uninstall | status         run brain in the background, so changes made in your dashboard apply here by themselves
+brain moves [approve|refuse <id>]                  session moves asked from your dashboard that wait for you on this computer
 brain --version                                    the version, and where this brain runs from
 brain expand <blob id>                              the full text of a tool output that was replaced by a digest`
 
@@ -70,39 +71,25 @@ async function reportLater() {
 }
 
 async function allRefs(tool?: string): Promise<{ refs: SessionRef[]; errors: string[] }> {
-  const { READERS } = await adapters()
-  const readers = tool ? READERS.filter((r) => r.tool === tool) : READERS
-  if (tool && !readers.length) fail(`no reader for "${tool}"; readers: ${READERS.map((r) => r.tool).join(", ")}`)
-  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 }
+  const { readerFor } = await adapters()
+  if (tool && !readerFor(tool)) {
+    const { READERS } = await adapters()
+    fail(`no reader for "${tool}"; readers: ${READERS.map((r) => r.tool).join(", ")}`)
+  }
+  const { listSessions } = await import("./session/ops.ts")
+  return listSessions(home, tool)
 }
 
 async function resolveRef(given: string): Promise<SessionRef> {
-  // 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 adapters()
-  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
-  const { refs } = await allRefs(tool)
-  const exact = refs.filter((r) => r.sourceId === want)
-  const matches = exact.length ? exact : refs.filter((r) => r.sourceId.startsWith(want))
-  if (!matches.length) fail(`no session "${id}"; see \`brain session list\``)
-  if (matches.length > 1) fail(`"${id}" matches ${matches.length} sessions (${matches.slice(0, 4).map((r) => `${r.tool}:${r.sourceId}`).join(", ")}…); give more of the id`)
-  return matches[0]!
+  const { findSession } = await import("./session/ops.ts")
+  const r = await findSession(home, given)
+  if ("error" in r) fail(r.error)
+  return (r as { ref: SessionRef }).ref
 }
 
 async function readRef(ref: SessionRef): Promise<Session> {
-  const { readerFor } = await adapters()
-  return readerFor(ref.tool)!.read(ref, home)
+  const { readSession } = await import("./session/ops.ts")
+  return readSession(home, ref)
 }
 
 /**
@@ -155,46 +142,26 @@ function report(r: WriteResult) {
 }
 
 async function continueIn(source: Session, target: string, opts: { way?: Way; cwd?: string; dryRun: boolean; open: boolean; lean?: boolean; noMemory?: boolean; budget?: number; tidy?: false }) {
-  const { writersFor } = await adapters()
-  const candidates = writersFor(target).filter((w) => !opts.way || w.way === opts.way)
-  if (!candidates.length) fail(`can't continue in "${target}"${opts.way ? ` by ${opts.way}` : ""}; see \`brain session targets\``)
-  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 session = prepared.session
-  for (const n of prepared.notes) out(n)
-  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
-    }
-    for (const s of skipped) out(`(${s}; using the next way)`)
-    const r = await w.write(session, wopts)
-    report(r)
-    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 { readerFor } = await adapters()
-      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(session), lean: prepared.lean })
-    }
-    if (!r.dryRun && r.way === "brief") {
-      const brief = Bun.file(r.written[0]!)
-      // The clipboard where the system has one (pbcopy on macOS, wl-copy or xclip on Linux, clip on Windows); a missing tool is fine.
-      const copy = process.platform === "darwin" ? ["pbcopy"] : process.platform === "win32" ? ["clip"] : Bun.which("wl-copy") ? ["wl-copy"] : ["xclip", "-selection", "clipboard"]
-      let copied = false
-      try {
-        if (await brief.exists()) copied = Bun.spawnSync(copy, { stdin: Buffer.from(await brief.text()) }).exitCode === 0
-      } catch {}
-      if (copied) out("  (the brief is also on the clipboard)")
-    }
-    if (!r.dryRun && opts.open && target === "cursor") Bun.spawnSync(["/bin/sh", "-c", r.open])
-    if (!r.dryRun) await reportLater()
-    return
+  const { moveSession } = await import("./session/ops.ts")
+  const { open, ...moveOpts } = opts
+  const m = await moveSession(home, source, target, moveOpts)
+  for (const n of m.notes) out(n)
+  if (!m.ok) fail(m.why)
+  const r = (m as { result: WriteResult }).result
+  for (const s of m.skipped) out(`(${s}; using the next way)`)
+  report(r)
+  if (!r.dryRun && r.way === "brief") {
+    const brief = Bun.file(r.written[0]!)
+    // The clipboard where the system has one (pbcopy on macOS, wl-copy or xclip on Linux, clip on Windows); a missing tool is fine.
+    const copy = process.platform === "darwin" ? ["pbcopy"] : process.platform === "win32" ? ["clip"] : Bun.which("wl-copy") ? ["wl-copy"] : ["xclip", "-selection", "clipboard"]
+    let copied = false
+    try {
+      if (await brief.exists()) copied = Bun.spawnSync(copy, { stdin: Buffer.from(await brief.text()) }).exitCode === 0
+    } catch {}
+    if (copied) out("  (the brief is also on the clipboard)")
   }
-  fail(`no way to continue in "${target}" right now: ${skipped.join("; ")}`)
+  if (!r.dryRun && open && target === "cursor") Bun.spawnSync(["/bin/sh", "-c", r.open])
+  if (!r.dryRun) await reportLater()
 }
 
 /** --lean / --full into the option (neither: decided by the session's size). */
@@ -306,6 +273,25 @@ async function main() {
     if (code === 0 && (rest[0] === "login" || (rest[0] === "logout" && was))) await reportLater()
     process.exit(code)
   }
+  if (cmd === "moves") {
+    const { decidePending, movesState, readPending } = await import("./moves.ts")
+    const sub = rest[0]
+    if (sub === "approve" || sub === "refuse") {
+      const id = rest[1] ?? fail(`moves ${sub} needs a move id (brain moves lists them)`)
+      const r = await decidePending(home, id, sub === "approve")
+      out(r.message)
+      if (r.ok && sub === "approve") await reportLater()
+      process.exit(r.ok ? 0 : 1)
+    }
+    if (sub && sub !== "list") fail(`unknown moves command "${sub}"; usage: brain moves [approve|refuse <id>]`)
+    const st = movesState(home)
+    out(`moves from the dashboard: ${st.setting === "ask" ? "asks you first" : st.setting === "allow" ? "run without asking" : "off (refused)"} (brain settings set moves.fromDashboard ask|allow|off)`)
+    const p = readPending(home).moves
+    if (!p.length) out("nothing waits for you here")
+    const { plainText } = await import("./moves.ts")
+    for (const m of p) out(`  ${m.id}  ${m.session}${m.title ? ` ("${plainText(m.title, 80)}")` : ""} to ${m.to}${m.way ? ` by ${m.way}` : ""}  asked ${ago(m.askedAt)}: brain moves approve ${m.id} | brain moves refuse ${m.id}`)
+    process.exit(0)
+  }
   if (cmd === "expand") {
     const id = rest[0] ?? fail("expand needs a blob id (from a digest: \"id=...\")")
     const { openBlobStore } = await import("./memory/blobs.ts")
@@ -323,7 +309,7 @@ async function main() {
     options: {
       tool: { type: "string" }, here: { type: "boolean" }, limit: { type: "string" }, json: { type: "boolean" },
       in: { type: "string" }, way: { type: "string" }, cwd: { type: "string" }, from: { type: "string" },
-      "dry-run": { type: "boolean" }, "no-open": { type: "boolean" }, lean: { type: "boolean" }, full: { type: "boolean" }, "no-memory": { type: "boolean" }, budget: { type: "string" }, "no-tidy": { type: "boolean" }, o: { type: "string" }, help: { type: "boolean", short: "h" },
+      "dry-run": { type: "boolean" }, "no-open": { type: "boolean" }, print: { type: "boolean" }, lean: { type: "boolean" }, full: { type: "boolean" }, "no-memory": { type: "boolean" }, budget: { type: "string" }, "no-tidy": { type: "boolean" }, o: { type: "string" }, help: { type: "boolean", short: "h" },
     },
   })
   if (!sub || values.help) return out(USAGE)
@@ -366,6 +352,20 @@ async function main() {
     out(`Handing off ${ref!.tool}:${ref!.sourceId}${ref!.title ? ` ("${cut(ref!.title, 60)}")` : ""}, ${ago(ref!.updatedAt)}.`)
     return continueIn(await readRef(ref!), target, { ...(values.way ? { way: values.way as Way } : {}), cwd: here, dryRun: !!values["dry-run"], open: !values["no-open"], ...leanOf(values), ...budgetOf(values), ...(values["no-tidy"] ? { tidy: false as const } : {}), ...(values["no-memory"] ? { noMemory: true } : {}) })
   }
+  if (sub === "open") {
+    const id = positionals[0] ?? fail("open needs a session id")
+    const ref = await resolveRef(id)
+    const { openPlan } = await import("./session/open.ts")
+    const { readerFor } = await adapters()
+    const plan = openPlan(ref, readerFor(ref.tool)?.label ?? ref.tool, home)
+    if ("none" in plan) fail(plan.none)
+    const p = plan as { command: string; note?: string }
+    if (values.print) return out(p.command)
+    out(`Opening ${readerFor(ref.tool)?.label ?? ref.tool}${ref.title ? ` "${cut(ref.title, 60)}"` : ""}: ${p.command}`)
+    if (p.note) out(`  ${p.note}`)
+    const child = Bun.spawn(["/bin/sh", "-c", p.command], { stdio: ["inherit", "inherit", "inherit"] })
+    process.exit(await child.exited)
+  }
   if (sub === "targets") {
     const { READERS, WRITERS, writersFor } = await adapters()
     const targets = [...new Set(WRITERS.map((w) => w.tool))]

package/src/dashboard/cli.ts

@@ -59,7 +59,15 @@ export async function dashboardCommand(
   args: string[],
   home: string,
   io: { out(l: string): void; err(l: string): void } = { out: (l) => process.stdout.write(`${l}\n`), err: (l) => process.stderr.write(`${l}\n`) },
-  deps: { env?: Env; fetchImpl?: typeof fetch; open?: (url: string) => void; countTimeoutMs?: number; readers?: Reader[] } = {},
+  deps: {
+    env?: Env
+    fetchImpl?: typeof fetch
+    open?: (url: string) => void
+    countTimeoutMs?: number
+    readers?: Reader[]
+    /** Where sessions can go (runs each tool's `--version`); tests give a stand-in so they do not run the machine's tools. */
+    refreshTargets?: (home: string) => Promise<void>
+  } = {},
 ): Promise<number> {
   const env = deps.env ?? process.env
   const atAt = args.indexOf("--at")
@@ -83,7 +91,14 @@ export async function dashboardCommand(
   const send = async (counts: boolean): Promise<void> => {
     // The notice goes where the person reads it: the output, or stderr when the output is asked to stay quiet.
     noticeOnce(home, quiet ? io.err : io.out)
-    const { buildReport, countAndKeep } = await import("./report.ts")
+    const { buildReport, countAndKeep, refreshTargets } = await import("./report.ts")
+    // `brain dashboard` (the person's command): where sessions can go, and the session list, now.
+    if (counts) {
+      await (deps.refreshTargets ?? refreshTargets)(home)
+      const { sendSessions } = await import("./sessions.ts")
+      const s = await sendSessions(home, { env, force: true, ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}) })
+      if (s.sent) say(`sent this computer's session list (${s.total} sessions)`)
+    }
     const report = await buildReport(home, {
       env,
       ...(counts ? { counts: await countAndKeep(home, { timeoutMs: deps.countTimeoutMs ?? 20_000, ...(deps.readers ? { readers: deps.readers } : {}) }) } : {}),

package/src/dashboard/report.ts

@@ -49,12 +49,23 @@ export interface BrainReport {
     contextEdit: boolean
     connected: Array<{ tool: string; label: string; since: string | null }>
   }
-  memory: { available: true; projects: number; items: number } | { available: false }
+  memory: { available: true; projects: number; items: number; projectList?: Array<{ name: string; items: number }> } | { available: false }
   conversions: Conversion[]
   /** byMonth: conversions per month, UTC "YYYY-MM", the latest twelve months that have any. */
   totals: { conversions: number; byMonth: Record<string, number> }
   /** Every setting on this computer and its state (docs/settings-contract.md, section 3). Absent when it could not be read. */
   settings?: SettingsSection
+  // docs/sessions-contract.md, section 3: what the dashboard needs to show every feature. Each is optional.
+  /** Where a session can go from this computer, as `brain session targets` says. */
+  targets?: Array<{ tool: string; label: string; ways: Array<{ way: string; ready: boolean; why?: string }> }>
+  /** How often each kind of digested tool output is asked back (`brain tokens lookups`). */
+  tokens?: { lookups: Array<{ kind: string; stubbed: number; expanded: number }> }
+  /** Team memory (`brain org`): the server's host only, never its token. */
+  org?: { joined: true; server: string; scope: string | null } | { joined: false }
+  /** What was last sent of the session list (sessions.ts). */
+  sessions?: { total: number; uploadedAt: string | null; off: boolean }
+  /** Moves from the dashboard (moves.ts): this computer's setting, and how many wait here for the person. */
+  moves?: { setting: string; waiting: number }
 }
 
 export interface SettingsRow {
@@ -235,7 +246,10 @@ async function memorySummary(home: string, env: Env): Promise<BrainReport["memor
           const s = await mem.status()
           if (!s.available) return { available: false as const }
           const projects = await mem.projects()
-          return { available: true as const, projects: projects.length, items: projects.reduce((n, p) => n + (Number(p.items) || 0), 0) }
+          // A project's name as memory labels it; a path in it is written from the home folder (~).
+          const name = (l: string) => clip(String(l ?? "").replaceAll(home, "~").replace(/[\u0000-\u001f\u007f]/g, " ").trim(), 80) || "(unnamed)"
+          const projectList = [...projects].sort((a, b) => (Number(b.items) || 0) - (Number(a.items) || 0)).slice(0, 50).map((p) => ({ name: name(p.label), items: Math.max(0, Math.floor(Number(p.items) || 0)) }))
+          return { available: true as const, projects: projects.length, items: projects.reduce((n, p) => n + (Number(p.items) || 0), 0), projectList }
         })(),
         5_000,
       )
@@ -303,6 +317,11 @@ export async function harnesses(home: string, counts: Record<string, ToolCount>
   }
   for (const t of MCP_TOOLS) add(mcpToolId(t.id), t.label, mcpToolHere(t, home, env) || mcpInstalled.get(mcpToolId(t.id)) === true)
   for (const id of HOOK_TOOLS) add(id, toolLabel(id), hookOn(id))
+  // The Codex app (its threads share ~/.codex with the CLI).
+  try {
+    const { codexAppHere } = await import("../adapters/codex/records.ts")
+    add("codex-desktop", "Codex Desktop", codexAppHere(home))
+  } catch {}
   const mcpIds = new Set(MCP_TOOLS.map((t) => mcpToolId(t.id)))
   const connectorIds = new Set(CONNECTORS.map((c) => c.id))
   return [...known.entries()]
@@ -312,9 +331,11 @@ export async function harnesses(home: string, counts: Record<string, ToolCount>
       label: clip(k.label, 80),
       sessions: counts?.[id] ? counts[id]!.sessions : null,
       lastSessionAt: counts?.[id]?.lastSessionAt ?? null,
-      gateway: connected[id] ? "connected" : (ownClient(id, home, env) ?? (connectorIds.has(id) ? "available" : "unsupported")),
-      mcp: mcpIds.has(id) ? mcpInstalled.get(id) === true : null,
-      hooks: HOOK_TOOLS.includes(id) ? hookOn(id) : null,
+      // The Codex app reads Codex's own settings (~/.codex): its gateway and MCP tools are Codex's.
+      gateway: id === "codex-desktop" ? (connected.codex ? "connected" : "available") : connected[id] ? "connected" : (ownClient(id, home, env) ?? (connectorIds.has(id) ? "available" : "unsupported")),
+      mcp: id === "codex-desktop" ? mcpInstalled.get("codex") === true : mcpIds.has(id) ? mcpInstalled.get(id) === true : null,
+      // Claude Desktop's Code tab runs Claude Code's hooks.
+      hooks: HOOK_TOOLS.includes(id) ? hookOn(id) : id === "claude-desktop" ? hookOn("claude-code") : id === "codex-desktop" && HOOK_TOOLS.includes("codex") ? hookOn("codex") : null,
     }))
     .sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id))
 }
@@ -353,9 +374,72 @@ export async function buildReport(home: string, o: { counts?: Record<string, Too
     conversions: list,
     totals: { conversions: total, byMonth },
     ...(settings ? { settings } : {}),
+    ...(await featureParts(home)),
   }
 }
 
+/** Where a session can go from this computer: each tool brain writes, and whether each way is ready now (dry run). */
+export async function targetsPart(home: string): Promise<BrainReport["targets"]> {
+  const { WRITERS, readerFor } = await import("../adapters/index.ts")
+  const { cleanText } = await import("../settings/catalog.ts")
+  const byTool = new Map<string, { tool: string; label: string; ways: Array<{ way: string; ready: boolean; why?: string }> }>()
+  await Promise.all(
+    WRITERS.map(async (w) => {
+      let ready = false
+      let why: string | undefined
+      try {
+        const r = await w.ready({ home, cwd: home, dryRun: true })
+        ready = r.ok
+        if (!r.ok) why = clip(cleanText(r.why, home), 200)
+      } catch (e) {
+        why = clip(cleanText(String((e as Error)?.message ?? e), home), 200)
+      }
+      const t = byTool.get(w.tool) ?? { tool: w.tool, label: clip(readerFor(w.tool === "cursor" ? "cursor-ide" : w.tool)?.label ?? w.label ?? w.tool, 60), ways: [] }
+      t.ways.push({ way: w.way, ready, ...(why ? { why } : {}) })
+      byTool.set(w.tool, t)
+    }),
+  )
+  const order = new Map(WRITERS.map((w, i) => [w.tool, i]))
+  return [...byTool.values()].sort((a, b) => (order.get(a.tool) ?? 0) - (order.get(b.tool) ?? 0)).slice(0, 60)
+}
+
+/** Works out where a session can go from here now and keeps it for the reports that follow (explicit commands only). */
+export async function refreshTargets(home: string, timeoutMs = 15_000): Promise<void> {
+  const list = await withTimeout(targetsPart(home), timeoutMs)
+  if (list?.length) updateCache(home, (c) => {
+    c.targets = { at: new Date().toISOString(), list }
+  })
+}
+
+/** The additions the dashboard's every-feature panel reads (docs/sessions-contract.md, section 3); each one alone may fail. */
+async function featureParts(home: string): Promise<Pick<BrainReport, "targets" | "tokens" | "org" | "sessions" | "moves">> {
+  const out: Pick<BrainReport, "targets" | "tokens" | "org" | "sessions" | "moves"> = {}
+  // From the last `brain dashboard` / `brain sync`: a writer's check may run its tool (`--version`), never in the background.
+  const targets = readCache(home).targets?.list
+  if (Array.isArray(targets) && targets.length) out.targets = targets.slice(0, 60)
+  try {
+    const { lookupRates } = await import("../memory/lookups.ts")
+    out.tokens = { lookups: lookupRates(home).slice(0, 30).map((r) => ({ kind: clip(r.kind, 40), stubbed: r.stubbed, expanded: r.expanded })) }
+  } catch {}
+  try {
+    const cfg = readOrgConfig(home)
+    let host = ""
+    try {
+      host = cfg ? new URL(cfg.server).host : ""
+    } catch {}
+    out.org = cfg && host ? { joined: true, server: clip(host, 120), scope: typeof cfg.defaultScope === "string" ? clip(cfg.defaultScope, 20) : null } : { joined: false }
+  } catch {}
+  try {
+    const { sessionsState } = await import("./sessions.ts")
+    out.sessions = sessionsState(home)
+  } catch {}
+  try {
+    const { movesState } = await import("../moves.ts")
+    out.moves = movesState(home)
+  } catch {}
+  return out
+}
+
 /** The report as it is sent: at most MAX_BYTES of JSON, the oldest conversions dropped first if it is bigger. */
 export function reportBody(r: BrainReport, maxBytes = MAX_BYTES): string {
   let body = JSON.stringify(r)