heyquilt 0.0.1 → 0.3.90

package/src/control.js

@@ -0,0 +1,245 @@
+// Local control API (127.0.0.1 only) so the CLI and the MCP server can talk to
+// a running session. Discovery info is written to .quilt/daemon.json.
+import http from 'node:http'
+import fs from 'node:fs'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { renderStatus } from './status.js'
+import { migrateDir } from './legacy.js'
+
+export async function startControl (session, extras = {}) {
+  const token = crypto.randomBytes(16).toString('hex')
+  const routes = {
+    'GET /status': (b) => {
+      // To one of the AI sessions working through this app, "you" is that session (persona.js).
+      const st = session.status()
+      const p = session.persona(b.via)
+      if (p) st.me = { ...st.me, name: p.name, tool: p.tool || st.me.tool, kind: 'agent', persona: true, of: session.name, focus: p.focus || '' }
+      return { ...st, markdown: renderStatus(st) }
+    },
+    // An AI session (one `quilt mcp`) says hello: { via, tool, cwd, ppid } -> { name, named }.
+    'POST /persona': (b) => session.registerPersona({ via: b.via, tool: b.tool, cwd: b.cwd, ppid: b.ppid, pids: b.mcpPids }),
+    // It names itself after its work: { via, name } -> { name }.
+    'POST /persona/name': (b) => session.renamePersona(b.via, b.name, 'self'),
+    // What the person asked their AI session (a prompt hook): names a session that has no name yet.
+    'POST /persona/prompt': (b) => { session.personaPrompt(b.via, b.text); return { ok: true } },
+    // The CLI and the MCP server: what an AI sends, held to the chat rules (duties.js). A person typing in `quilt join` sends with everyone.
+    'POST /say': (b) => session.say(b.text, { to: b.to, agent: true, via: b.via ? String(b.via) : null, everyone: !!b.everyone, also: !!b.also, re: typeof b.re === 'string' ? b.re.slice(0, 40) : '' }),
+    // "… is typing" in chat, for an AI session (via) or this member: { on, to } (sending clears it).
+    'POST /typing': (b) => session.setTyping(b.on !== false, { via: b.via ? String(b.via) : null, to: b.to || null, agent: true }),
+    'POST /inbox/settle': (b) => session.settle(b.ids),
+    'POST /send': (b) => session.sendFile(b.path, { to: b.to, text: b.text }),
+    'POST /conversation': (b) => session.conversation({ with: b.with || null, q: b.q || '', before: b.before || null, limit: b.limit, via: b.via ? String(b.via) : null }),
+    'POST /messages': (b) => ({ messages: session.messages({ limit: b.limit || 50, unreadOnly: !!b.unreadOnly, markRead: b.markRead !== false, withName: b.with || null }) }),
+    'POST /get': async (b) => ({ path: await session.fetchFile(b.id, b.dest) }),
+    'POST /focus': (b) => {
+      // An AI session's focus is its own (and names it, if it has no name yet); a person's is theirs.
+      if (session.persona(b.via)) session.personaSays(b.via, b.text)
+      else session.setFocus(b.text)
+      return { ok: true }
+    },
+    'POST /claim': (b) => session.claim(b.pattern, b.note, b.via),
+    // What this person's AI should hear (an edit of its that Quilt undone); handed over once.
+    'POST /notices': (b) => ({ notices: session.takeNotices(b && b.via ? String(b.via) : null) }),
+    'POST /release': async (b) => ({ released: await session.release(b.pattern, b.via) }),
+    'POST /unpack': (b) => session.unpack(b.paths, b.via),
+    // The file queue: ask for a file someone holds, hand one we hold to someone waiting, take a request back.
+    'POST /request-file': (b) => session.requestFile(b.path, { title: b.title, description: b.description, task: b.task, via: b.via }),
+    'POST /handoff': (b) => session.handoff(b.path, { to: b.to, context: b.context, via: b.via }),
+    'POST /withdraw-request': async (b) => ({ withdrawn: await session.withdrawRequest(b.request, b.via) }),
+    // Who owns one path (the hooks ask before every edit). `shared` is false for paths Quilt doesn't sync.
+    'POST /claim-for': (b) => {
+      const rel = String(b.path || '').replace(/\\/g, '/').replace(/^\.\//, '')
+      const shared = session.syncable(rel)
+      const c = shared ? session.claimFor(rel) : null
+      const me = session.actorName(b.via)
+      return { path: rel, shared, claim: c ? { by: c.by, pattern: c.pattern, note: c.note, queue: c.queue || [] } : null, mine: !!c && c.by === me, me, focus: session.focus || '' }
+    },
+    // Before an agent changes files (any tool): is each one ours to edit (free ones are claimed for
+    // us), and what did people ask about them? See Session.prepareEdit and duties.js.
+    'POST /before-edit': (b) => session.prepareEdit(Array.isArray(b.paths) ? b.paths.slice(0, 100) : [], b.via),
+    // An agent finished a piece of work: let go of the claims that followed its edits.
+    'POST /finish': (b) => session.finishEditing(b.via),
+    // Who is waiting for an answer from this member (or AI session): the MCP and the hooks refuse to move work on until there's none.
+    'GET /duties': (b) => session.duties(b.via),
+    // What an MCP agent shares about its work (quilt_share): the feed, tasks and "working", for any tool.
+    'POST /share-work': (b) => {
+      session.personaSays(b.via, b.request)
+      return session.shareAgentWork({ tool: b.tool, request: b.request, summary: b.summary, files: Array.isArray(b.files) ? b.files : [] })
+    },
+    // Owner only: a link a chat-only AI works through (chat-links.js). { name, hours } -> { url, name, expiresAt }
+    'POST /chat-link': (b) => session.createChatLink({ name: b.name, minutes: b.minutes }),
+    // Owner only: how long a chat link still works. { who: name or key, minutes } -> { name, expiresAt }
+    'POST /chat-link/extend': (b) => session.extendChatLink(String(b.who || ''), b.minutes),
+    // Owner only: the relay's read-only GitHub token, for commits while everyone's offline. { token } ('' clears) -> { githubToken }
+    'POST /github-token': (b) => session.setGithubToken(b.token),
+    'POST /agent': (b) => { session.addAgent(b.client); return { ok: true } },
+    'POST /feed': (b) => ({ entries: session.agentFeedFor(b.who, { limit: Math.min(Number(b.limit) || 40, 300) }) }),
+    // The chronology: { path, by, since, task, limit } (see Session.historyQuery).
+    'POST /history': (b) => ({ entries: session.historyQuery(b) }),
+    'GET /tree': () => session.tree(),
+    'POST /sharing': (b) => ({ on: session.setAgentSharing(b.on !== false) }),
+    'GET /commits': () => session.commitStatus({ includeMe: false }),
+    'GET /branches': () => ({ branches: session.status().branches, git: session.status().git }),
+    // The relay's own list, with where each branch stands with GitHub (quilt_sync_status).
+    'GET /sync-status': () => ({ branches: session.branchList || [], mine: session.branchKey ? session.branchKey() : '' }),
+    'POST /branches/sync': () => session.syncBranchNow(),
+    'POST /commit-request': (b) => session.requestCommit(b.message, { files: b.files == null ? null : b.files, description: b.description || '', task: b.task || null, via: b.via ? String(b.via) : null }),
+    // quilt_commit: the relay commits the session's copy of the files to GitHub (relay-commit.js).
+    'POST /agent-commits': (b) => session.setAgentCommits(b.mode),
+    // GitHub as a node: the owner's switch, and a person adopting an agent's branch (relay-outbound.js).
+    'POST /github-sync': async (b) => (await session.setGithubSync(b.on !== false)).githubSync === false ? { githubSync: false } : { githubSync: true },
+    'POST /adopt': (b) => session.adoptBranch(String(b.from || '')),
+    // The branch's pull requests on GitHub, and merging one, through the relay (relay-commit.js).
+    'POST /github/recheck': () => session.githubRecheck(),
+    'POST /unpublished': (b) => session.unpublished({ files: Array.isArray(b.files) ? b.files : null, task: b.task || null, column: b.column || '' }),
+    // git in an agent's folder: what it signs in to GitHub with (`quilt git-credential`), and whether a push may go (`quilt git-pre-push`).
+    'POST /git/credential': (b) => session.gitCredential({ host: b.host || '' }),
+    'POST /git/push-check': (b) => session.pushCheck({ remote: b.remote || 'origin', refs: Array.isArray(b.refs) ? b.refs : [] }),
+
+    // A commit request committed in this folder, which has git (commit.js).
+    'POST /commit-request/commit': (b) => session.commitRequest(String(b.id || '')),
+    'GET /uncommitted': () => session.uncommittedWork(),
+    'POST /commit-request/done': (b) => ({ done: session.resolveCommitRequests({ ids: b.id ? [String(b.id)] : null }) }),
+    'POST /work': (b) => {
+      if (b.state === 'working') session.personaSays(b.via, b.note)
+      const work = session.setWork(b.state, b.note)
+      session.stitchClock(b.via, b.state === 'working')
+      if (b.state === 'working' && b.note) session.noteActivity(`Working on: ${b.note}`, { via: b.via })
+      else if (b.state === 'done') session.noteActivity(b.note ? `Done: ${b.note}` : 'Done', { via: b.via })
+      return { work }
+    },
+    'GET /tasks': () => ({ tasks: session.taskList() }),
+    // Mentions, direct messages and tasks handed to this member since sequence number `after` (agents wake on these).
+    'POST /inbox': (b) => session.inbox({ after: b.after, all: !!b.all, via: b.via }),
+    // The agent's webhook: inbox events POSTed to a URL of its own (see webhooks.js).
+    'GET /webhook': () => ({ webhook: session.webhookInfo() }),
+    'POST /webhook': (b) => ({ webhook: session.setWebhook({ url: b.url, secret: b.secret, events: b.events, bearer: b.bearer }) }),
+    'POST /webhook/clear': () => ({ had: session.clearWebhook() }),
+    // Agents' task changes are written to their thread too (Session.noteTaskChange).
+    'POST /tasks': (b) => {
+      const task = session.addTask(b)
+      session.noteTaskChange(null, task, b.via)
+      return { task, tasks: session.taskList() }
+    },
+    'POST /tasks/update': async (b) => {
+      const before = session.taskList().find((t) => t.id === b.id) || null
+      // Done merges the task's pull request first (relay-commit.js): refused with the reason when it can't be.
+      const finished = b.column === 'done' && before && before.column !== 'done' ? await session.finishTask(b.id) : null
+      const task = session.updateTask(b)
+      session.noteTaskChange(before, task, b.via)
+      if (b.column === 'doing' && task) session.personaSays(b.via, task.title) // taking a task can name an AI session
+      if (task && (b.column === 'doing' || b.column === 'done')) session.stitchClock(b.via, b.column === 'doing')
+      // An agent taking a task gets a branch of its own for it (session.js branchForTask).
+      const branch = b.column === 'doing' && task && before && before.column !== 'doing' ? await session.branchForTask(task).catch(() => null) : null
+      return { task, tasks: session.taskList(), ...(finished && finished.merged ? { merged: finished.merged } : {}), ...(branch ? { branch } : {}) }
+    },
+    // What an agent gets when it picks a task up: history for its files, claims, the project's checks.
+    'POST /tasks/brief': (b) => session.taskBrief(b.id),
+    'POST /tasks/comment': (b) => {
+      const r = session.commentTask(b)
+      const t = session.taskList().find((x) => x.id === b.id)
+      if (t && b.text) session.noteActivity(`Note on "${String(t.title || '').slice(0, 120)}": ${String(b.text).slice(0, 400)}`, { via: b.via })
+      return r
+    },
+    'POST /tasks/delete': (b) => { session.deleteTask(b.id); return { tasks: session.taskList() } },
+    'GET /merges': () => {
+      const merges = session.mergeList()
+      // Agents are told the other version is under .quilt/merges/<id>/, so put
+      // it there on this machine too (base and ours are written once). A local
+      // record's versions are only on the opener's machine; skip any that fail.
+      for (const m of merges) {
+        if (m.state !== 'open' || m.local) continue
+        try { session.prepareMergeSend(m.id) } catch {}
+      }
+      return { merges }
+    },
+    'POST /merges/resolve': (b) => session.settleMerge(String(b.id || ''), { how: b.how }),
+    // quilt_clash: a file held because the session and GitHub changed the same lines (relay-clash.js).
+    'POST /clash': (b) => session.clash({ action: String(b.action || ''), path: String(b.path || ''), content: typeof b.content === 'string' ? b.content : null, checks: b.checks && typeof b.checks === 'object' ? b.checks : null, force: b.force === true }),
+    'POST /merges/send': (b) => session.sendMerge(String(b.id || '')),
+    'GET /rules': () => ({ text: session.projectRulesText() }),
+    'GET /info': (b) => ({ room: session.room, dir: session.root, name: session.actorName(b.via), person: session.name, kind: session.kind, invite: extras.invite || null, viewInvite: extras.viewInvite || null, access: session.access, pid: process.pid })
+  }
+  const server = http.createServer(async (req, res) => {
+    const reply = (code, body) => {
+      res.writeHead(code, { 'content-type': 'application/json' })
+      res.end(JSON.stringify(body))
+    }
+    if (req.headers.authorization !== `Bearer ${token}`) return reply(401, { error: 'unauthorized' })
+    if (req.method === 'GET' && req.url === '/events') return streamEvents(session, req, res)
+    const route = routes[`${req.method} ${req.url.split('?')[0]}`]
+    if (!route) return reply(404, { error: 'not found' })
+    let raw = ''
+    for await (const chunk of req) raw += chunk
+    try {
+      const b = raw ? JSON.parse(raw) : {}
+      // Which AI session is asking (persona.js): `via` from its MCP server, or `pids` from a hook
+      // (the session whose tool process is among the hook's parents). GETs carry it in the query.
+      const q = new URL(req.url, 'http://x').searchParams
+      if (!b.via && q.get('via')) b.via = q.get('via')
+      if (!b.pids && q.get('pids')) b.pids = q.get('pids').split(',')
+      if (!b.via && b.pids) b.via = session.personaFor(b.pids)
+      // A background poll (the inbox push loop) is not the AI at work: only real calls keep it here.
+      if (b.via && !b.poll) session.touchPersona(b.via)
+      reply(200, await route(b))
+    } catch (err) {
+      reply(400, { error: err.message })
+    }
+  })
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
+  const file = path.join(session.stateDir, 'daemon.json')
+  fs.writeFileSync(file, JSON.stringify({ port: server.address().port, token, pid: process.pid }), { mode: 0o600 })
+  return {
+    close: () => {
+      try { fs.rmSync(file) } catch {}
+      return new Promise((r) => server.close(r))
+    }
+  }
+}
+
+// Server-sent events: pushes each new message as it arrives (used by `quilt chat`).
+function streamEvents (session, req, res) {
+  res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache', connection: 'keep-alive' })
+  res.write(': connected\n\n')
+  const onMessage = (msg) => {
+    res.write(`event: message\ndata: ${JSON.stringify(msg)}\n\n`)
+    if (msg.by !== session.name) session.markRead([msg.id])
+  }
+  const onLog = (line) => res.write(`event: log\ndata: ${JSON.stringify(line)}\n\n`)
+  const ping = setInterval(() => res.write(': ping\n\n'), 15000)
+  session.on('message', onMessage)
+  session.on('log', onLog)
+  req.on('close', () => {
+    clearInterval(ping)
+    session.off('message', onMessage)
+    session.off('log', onLog)
+  })
+}
+
+/** Finds the nearest folder (from `start` upward) with a running session. */
+export function findDaemon (start = process.env.QUILT_DIR || process.cwd()) {
+  let dir = path.resolve(start)
+  while (true) {
+    const file = path.join(migrateDir(dir), 'daemon.json')
+    if (fs.existsSync(file)) {
+      const info = JSON.parse(fs.readFileSync(file, 'utf8'))
+      try { process.kill(info.pid, 0) } catch { return null } // stale
+      return { ...info, dir }
+    }
+    const parent = path.dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+}
+
+export async function call (daemon, method, route, body) {
+  const res = await fetch(`http://127.0.0.1:${daemon.port}${route}`, {
+    method,
+    headers: { authorization: `Bearer ${daemon.token}`, 'content-type': 'application/json' },
+    body: body ? JSON.stringify(body) : undefined
+  })
+  const json = await res.json()
+  if (!res.ok) throw new Error(json.error || `HTTP ${res.status}`)
+  return json
+}

package/src/conversation.js

@@ -0,0 +1,125 @@
+// The conversation between two members: what one said to the other (direct messages either
+// way, messages in the room that @mention the other, and what either said in the room to
+// nobody in particular, which is how people talk on). An agent woken by one message
+// (a webhook, a channel event, quilt_inbox) is often a fresh session that knows nothing of
+// what came before: "is that tool live?" means nothing without the ten messages above it.
+// So every wake carries the recent conversation with whoever woke it (contextFor), and
+// quilt_conversation reads further back, searches it, or lists everything the reader can see.
+//
+// Pure: messages in, messages out. The local daemon, the hosted relay MCP and the webhooks
+// all use it, so every agent, whatever tool it runs in, gets the same context.
+import { mentioned, mentionsAnyone, ALL_AGENTS, messageLine, renderContext, CONTEXT_MESSAGE_CHARS } from './inbox.js'
+
+export { messageLine, renderContext }
+
+// What a wake carries: the last few messages, each cut short, within a budget for the whole.
+export const CONTEXT_MESSAGES = 10
+export const CONTEXT_CHARS = 4000
+export { CONTEXT_MESSAGE_CHARS }
+export const MAX_QUERY = 200
+
+const lower = (names) => new Set((names || []).filter(Boolean).map((n) => String(n).toLowerCase()))
+
+/**
+ * Whether `m` passes between `me` (the reader's names) and `other` (the other member's names):
+ * a direct message from one to the other, or a room message by one that @mentions the other
+ * (@Agents counts for an agent reader) or names nobody at all (a message to someone else is not
+ * part of it). `of` (the person an AI session works for) counts as the sender too, so
+ * "Daniel · fix bug" writing for Daniel is Daniel's side of the conversation.
+ */
+export function between (m, me, other, { agent = false } = {}) {
+  if (!m || typeof m.text !== 'string') return false
+  const mine = lower(me)
+  const theirs = lower(other)
+  const by = String(m.by || '').toLowerCase()
+  const of = String(m.of || '').toLowerCase()
+  const to = m.to ? String(m.to).toLowerCase() : ''
+  const fromThem = theirs.has(by) || (of && theirs.has(of))
+  const fromMe = mine.has(by)
+  if (fromThem && !fromMe) return to ? mine.has(to) : !mentionsAnyone(m.text) || mentioned(m.text, [...me, ...(agent ? [ALL_AGENTS] : [])]).length > 0
+  if (fromMe && !fromThem) return to ? theirs.has(to) : !mentionsAnyone(m.text) || mentioned(m.text, other).length > 0
+  return false
+}
+
+const cut = (text, max) => {
+  const t = String(text || '').trim()
+  return t.length > max ? t.slice(0, max - 1).trimEnd() + '…' : t
+}
+
+const slim = (m, max) => ({ id: m.id, by: m.by, ...(m.to ? { to: m.to } : {}), text: cut(m.text, max), ts: m.ts })
+
+/**
+ * The conversation between `me` and `other` before the message `before` (an id or a timestamp):
+ * at most `max` messages and `chars` characters, oldest first. `earlier` counts what is left out.
+ * `pin`: the id of a message always shown (the one being answered), even when older than the rest.
+ */
+export function contextFor (messages, { me, other, before = null, max = CONTEXT_MESSAGES, chars = CONTEXT_CHARS, each = CONTEXT_MESSAGE_CHARS, agent = false, pin = '' } = {}) {
+  const list = messages || []
+  let end = list.length
+  const i = typeof before === 'string' ? list.findIndex((m) => m && m.id === before)
+    : typeof before === 'number' ? list.findIndex((m) => m && (m.ts || 0) >= before) : -1
+  if (i >= 0) end = i
+  const all = []
+  for (let i = 0; i < end; i++) if (between(list[i], me, other, { agent })) all.push(list[i])
+  const out = []
+  let used = 0
+  for (let i = all.length - 1; i >= 0 && out.length < max; i--) {
+    const s = slim(all[i], each)
+    if (out.length && used + s.text.length > chars) break
+    used += s.text.length
+    out.unshift(s)
+  }
+  const shown = out.length
+  let pinned = false
+  if (pin && !out.some((m) => m.id === pin)) {
+    const p = list.find((m) => m && m.id === pin)
+    if (p) { out.unshift(slim(p, each)); pinned = all.includes(p) }
+  }
+  return { messages: out, earlier: all.length - shown - (pinned ? 1 : 0) }
+}
+
+/**
+ * Adds `context` (contextFor) to each message or task event: the conversation with whoever it is
+ * from, before it. `reader`: { names, agent }. Events are inbox events ({ id, kind, by, ts }).
+ */
+export function withContext (events, messages, reader, opts = {}) {
+  return (events || []).map((e) => {
+    if (!e || !e.by || e.context) return e
+    const before = e.kind === 'dm' || e.kind === 'mention' ? e.id : (e.ts || null)
+    const c = contextFor(messages, { me: reader.names, other: [e.by], before, agent: !!reader.agent, pin: e.re || '', ...opts })
+    return c.messages.length ? { ...e, context: c.messages, earlier: c.earlier } : e
+  })
+}
+
+/**
+ * Reads the chat a member can see: everything, or only the conversation `with` someone; only
+ * what contains `q` (any case, in the text or the sender's name); only before message `before`.
+ * Newest `limit`, oldest first. { messages, more }: more says older matches exist (ask with
+ * before: the first id).
+ */
+export function queryConversation (messages, { me = [], with: other = null, q = '', before = null, limit = 30, agent = false } = {}) {
+  let list = (messages || []).filter((m) => m && typeof m.id === 'string')
+  if (before) {
+    const i = list.findIndex((m) => m.id === before)
+    if (i >= 0) list = list.slice(0, i)
+  }
+  if (other) list = list.filter((m) => between(m, me, [other], { agent }))
+  const needle = String(q || '').trim().toLowerCase()
+  if (needle) list = list.filter((m) => String(m.text || '').toLowerCase().includes(needle) || String(m.by || '').toLowerCase().includes(needle))
+  const n = Math.max(1, Math.min(Number(limit) || 30, MAX_QUERY))
+  return { messages: list.slice(-n), more: list.length > n }
+}
+
+/** quilt_conversation's answer. */
+export function renderConversation ({ messages, more }, { me = [], with: other = null, q = '', now = Date.now() } = {}) {
+  const what = `${other ? `between you and ${other}` : 'you can see'}${q ? ` containing "${q}"` : ''}`
+  if (!messages.length) return `No messages ${what}${other ? ' (Quilt keeps the session\'s recent chat; older messages may be gone)' : ''}.`
+  const lines = messages.map((m) => messageLine(m, { me, now }))
+  const older = more ? `\nOlder messages ${what}: call again with before: "${messages[0].id}".` : ''
+  return `Messages ${what}, oldest first:\n${lines.join('\n')}${older}`
+}
+
+/** What quilt_conversation does, the same for the local and the hosted tool. */
+export const CONVERSATION_DESCRIPTION = 'Read back through the chat, further than quilt_read_messages: the whole conversation between you and one person or agent ' +
+  '(direct messages either way, messages that @mention one of you, and what either of you said in the room to nobody in particular), or everything you can see; search it for some text; page back with before. ' +
+  'Read it whenever a message refers to something earlier ("that tool", "the fix", "is it live?") that you do not have in front of you: ask, do not guess.'

package/src/doctor.js

@@ -0,0 +1,156 @@
+// `quilt doctor`: explains what quilt can see of this machine's AI chats, so a
+// missing feed can be diagnosed from one pasted report. It prints counts,
+// lengths and names only, never chat text, so the report is safe to share.
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { cursorUserDir, findWorkspaces } from './agents/cursor.js'
+import { claudeProjectsDir, slugFor } from './agents/claude-code.js'
+import { startAgentReaders } from './agents/index.js'
+
+export async function doctor ({ dir = process.cwd(), watchSeconds = 0, print = console.log, cursorDir } = {}) {
+  dir = path.resolve(dir)
+  const say = (s = '') => print(s)
+  say(`quilt doctor for ${dir}`)
+  say(`node ${process.version} on ${process.platform}${cloudHint()}`)
+  say()
+  claude(dir, say)
+  say()
+  await cursor(dir, say, cursorDir)
+  if (watchSeconds > 0) {
+    say()
+    await watch(dir, watchSeconds, say)
+  }
+}
+
+function cloudHint () {
+  const env = process.env
+  if (env.CLAUDE_CODE_REMOTE) return ' · looks like a Claude Code cloud session'
+  if (env.CURSOR_AGENT || env.CURSOR_BACKGROUND_AGENT) return ' · looks like a Cursor cloud agent'
+  if (env.CODESPACES) return ' · GitHub Codespaces'
+  return ''
+}
+
+function claude (dir, say) {
+  say('## Claude Code')
+  const root = claudeProjectsDir()
+  if (!fs.existsSync(root)) return say(`- no ${root} (Claude Code hasn't run as this user on this machine)`)
+  const slug = slugFor(dir)
+  const dirs = fs.readdirSync(root).filter((n) => n.startsWith(slug))
+  if (!dirs.length) return say(`- no transcripts for this folder (looked for ${path.join(root, slug)}*)`)
+  for (const d of dirs) {
+    const files = fs.readdirSync(path.join(root, d)).filter((n) => n.endsWith('.jsonl'))
+    const newest = files.map((n) => fs.statSync(path.join(root, d, n)).mtimeMs).sort((a, b) => b - a)[0]
+    say(`- ${d}: ${files.length} conversation(s)${newest ? `, last written ${ago(newest)}` : ''}`)
+  }
+}
+
+async function cursor (dir, say, userDir = cursorUserDir()) {
+  say('## Cursor')
+  let DatabaseSync
+  const emit = process.emitWarning
+  process.emitWarning = () => {}
+  try { ({ DatabaseSync } = await import('node:sqlite')) } catch {
+    return say('- ✗ node:sqlite is missing: reading Cursor chats needs Node.js 22.13 or newer. This alone explains a missing Cursor feed.')
+  } finally { process.emitWarning = emit }
+
+  if (!fs.existsSync(userDir)) return say(`- no Cursor data at ${userDir} (Cursor isn't installed for this user, or runs elsewhere)`)
+  say(`- Cursor data: ${userDir}`)
+  const global = path.join(userDir, 'globalStorage', 'state.vscdb')
+  if (!fs.existsSync(global)) return say(`- ✗ missing ${global}`)
+  const found = findWorkspaces(userDir, dir)
+  if (!found.length) {
+    say('- ✗ Cursor has never opened this exact folder. Folders Cursor has opened recently:')
+    for (const f of recentWorkspaceFolders(userDir).slice(0, 12)) say(`    ${f}`)
+    say('  If the project is in that list under another path (a parent folder, a symlink, a different drive letter or case), open this exact folder in Cursor, or run quilt there.')
+    return
+  }
+  say(`- workspace folder(s) for this project: ${found.map((f) => path.basename(f)).join(', ')}`)
+
+  const open = (f) => new DatabaseSync(f, { readOnly: true })
+  const get = (db, table, key) => {
+    try {
+      const row = db.prepare(`SELECT value FROM ${table} WHERE key = ?`).get(key)
+      if (!row || row.value == null) return null
+      return JSON.parse(typeof row.value === 'string' ? row.value : Buffer.from(row.value).toString('utf8'))
+    } catch (err) { return { __error: err.message } }
+  }
+  const ids = new Map() // composerId -> lastUpdatedAt
+  const note = (c, from) => { if (c && c.composerId) ids.set(c.composerId, Math.max(ids.get(c.composerId) || 0, c.lastUpdatedAt || c.createdAt || 0)) ; return from }
+  for (const ws of found) {
+    const db = open(path.join(ws, 'state.vscdb'))
+    const list = get(db, 'ItemTable', 'composer.composerData')
+    db.close()
+    if (list && list.__error) say(`- ✗ ${path.basename(ws)}: can't read composer list (${list.__error})`)
+    else say(`- ${path.basename(ws)}: ${list && Array.isArray(list.allComposers) ? list.allComposers.length : 0} conversation(s) in the workspace list${list && list.hasMigratedComposerData ? ' (marked as migrated)' : ''}`)
+    for (const c of (list && list.allComposers) || []) note(c)
+  }
+  const g = open(global)
+  const headers = get(g, 'ItemTable', 'composer.composerHeaders')
+  if (headers && Array.isArray(headers.allComposers)) {
+    const wsIds = new Set(found.map((f) => path.basename(f)))
+    const mine = headers.allComposers.filter((c) => c && c.workspaceIdentifier && wsIds.has(c.workspaceIdentifier.id))
+    say(`- global conversation list: ${headers.allComposers.length} total, ${mine.length} tagged with this workspace`)
+    for (const c of mine) note(c)
+  } else say('- global conversation list: not present (older Cursor)')
+
+  const recent = [...ids].sort((a, b) => b[1] - a[1]).slice(0, 3)
+  if (!recent.length) say('- ✗ no conversations found for this folder yet. Send one message in Cursor\'s chat, then run this again.')
+  for (const [id, ts] of recent) {
+    const data = get(g, 'cursorDiskKV', `composerData:${id}`)
+    if (!data) { say(`- conversation ${id.slice(0, 8)} (${ago(ts)}): ✗ no composerData row`); continue }
+    if (data.__error) { say(`- conversation ${id.slice(0, 8)}: ✗ unreadable (${data.__error})`); continue }
+    const hs = Array.isArray(data.fullConversationHeadersOnly) ? data.fullConversationHeadersOnly : Array.isArray(data.conversation) ? data.conversation : null
+    if (!hs) { say(`- conversation ${id.slice(0, 8)}: ✗ unknown layout (_v ${data._v}, keys: ${Object.keys(data).slice(0, 12).join(', ')})`); continue }
+    say(`- conversation ${id.slice(0, 8)} (${ago(ts)}, layout _v ${data._v ?? '?'}): ${hs.length} message(s)`)
+    for (const h of hs.slice(-4)) {
+      const b = h.text !== undefined ? h : get(g, 'cursorDiskKV', `bubbleId:${id}:${h.bubbleId}`)
+      if (!b) { say(`    · ${h.bubbleId?.slice(0, 8)}: ✗ bubble row missing`); continue }
+      const kind = b.type === 1 ? 'you' : b.type === 2 ? 'AI' : `type ${b.type}`
+      const extra = [b.toolFormerData?.name && `tool ${b.toolFormerData.name}`, b.thinking && 'thinking', !b.text && b.richText && 'richText only'].filter(Boolean).join(', ')
+      say(`    · ${kind}: ${(b.text || '').length} chars${extra ? ` (${extra})` : ''}`)
+    }
+  }
+  g.close()
+}
+
+function recentWorkspaceFolders (userDir) {
+  const root = path.join(userDir, 'workspaceStorage')
+  const out = []
+  let names = []
+  try { names = fs.readdirSync(root) } catch { return out }
+  for (const n of names) {
+    try {
+      const ws = JSON.parse(fs.readFileSync(path.join(root, n, 'workspace.json'), 'utf8'))
+      const f = ws.folder || ws.workspace || ''
+      let shown = f
+      try { if (String(f).startsWith('file:')) shown = fileURLToPath(f) } catch {}
+      out.push({ shown, t: fs.statSync(path.join(root, n)).mtimeMs })
+    } catch {}
+  }
+  return out.sort((a, b) => b.t - a.t).map((x) => x.shown)
+}
+
+async function watch (dir, seconds, say) {
+  say(`## Live check (${seconds}s): send a message in Cursor or Claude Code now`)
+  let n = 0
+  const r = startAgentReaders({
+    dir,
+    onEntries: (es) => { for (const e of es) { n++; say(`- ${e.tool}: ${e.kind}, ${e.text.length} chars`) } },
+    onState: (s) => say(`- state: ${s.tool || 'no tool yet'} ${s.status}${s.reason ? ` (${s.reason})` : ''}${s.notes ? ` · ${s.notes.join('; ')}` : ''}`),
+    onLog: (l) => say(`- log: ${l}`)
+  })
+  await new Promise((resolve) => setTimeout(resolve, seconds * 1000))
+  r.stop()
+  say(n ? `- ✓ ${n} entr${n === 1 ? 'y' : 'ies'} would have been shared` : '- ✗ nothing would have been shared in that time')
+}
+
+function ago (ts) {
+  if (!ts) return 'unknown time'
+  const s = Math.round((Date.now() - ts) / 1000)
+  if (s < 90) return `${s}s ago`
+  if (s < 5400) return `${Math.round(s / 60)}m ago`
+  if (s < 172800) return `${Math.round(s / 3600)}h ago`
+  return `${Math.round(s / 86400)}d ago`
+}
+