heyquilt 0.3.90 → 0.3.107

package/src/mcp-proxy.js

@@ -6,9 +6,11 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js'
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js'
 import { hostedClient } from './hosted-client.js'
+import { secretNames } from './secrets-client.js'
+import { describeSecretNames, SECRET_NAMES_DESCRIPTION, RUN_GUIDE } from './secret-names.js'
 
 const NOTE = (room) => `\n\nYou reach Quilt with this sandbox's QUILT_AGENT_KEY: every tool is about session ${room}, filled in for you. ` +
-  'Your folder is synced by `npx heyquilt sync`: run it at the start of every turn (it brings in what changed and says what waits for you) and again at the end (it sends what you changed).'
+  'Your folder is synced by `npx heyquilt sync`: run it at the start of every turn (it brings in what changed and says what waits for you) and again at the end (it sends what you changed). ' + RUN_GUIDE
 
 /** The tools as the hosted MCP lists them, without `session` (the proxy fills it in). */
 export function withoutSession (tools) {
@@ -27,9 +29,12 @@ export async function runMcpProxy ({ key, client = hostedClient({ key }), transp
     instructions = (init && init.instructions) || ''
   } catch {} // the first tool call says what is wrong (a revoked key, no network)
   const server = new Server({ name: 'quilt', version: '0.2.0' }, { capabilities: { tools: {} }, instructions: instructions + NOTE(key.room) })
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: withoutSession((await client.rpc('tools/list', {})).tools) }))
+  // quilt_secret_names is answered here, as this agent with its key: a sandbox runs commands
+  // (through `quilt run`), unlike the hosted agents the relay's tool speaks to.
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: withoutSession((await client.rpc('tools/list', {})).tools).map((t) => (t.name === 'quilt_secret_names' ? { ...t, description: SECRET_NAMES_DESCRIPTION } : t)) }))
   server.setRequestHandler(CallToolRequestSchema, async (req) => {
     try {
+      if (req.params.name === 'quilt_secret_names') return { content: [{ type: 'text', text: describeSecretNames(await secretNames({ api: key.api, token: key.key }, key.room)) }] }
       return await client.callRaw(req.params.name, req.params.arguments || {})
     } catch (e) {
       return { content: [{ type: 'text', text: e.message }], isError: true }

package/src/mcp.js

@@ -39,6 +39,7 @@ import { UpdateCheck } from './update-check.js'
 import { getSettings } from './settings.js'
 import { mergeAction } from './merges.js'
 import { CLASH_DESCRIPTION, clashSchema } from './relay-clash.js'
+import { describeSecretNames, SECRET_NAMES_DESCRIPTION, RUN_GUIDE } from './secret-names.js'
 
 // The board's columns, from tasks.js, so this and the hosted MCP (relay-mcp.js) never drift apart.
 const COLUMN_IDS_LIST = COLUMNS.map((c) => c.id)
@@ -94,12 +95,11 @@ export const MCP_INSTRUCTIONS =
   'When you finish a piece of work, call quilt_set_work with "done": it lets go of the files claimed for you. ' +
   'Claim ahead (quilt_claim) only for a larger change across several files. ' +
   'Always re-read a file right before you edit it. ' +
-  'If quilt_status lists merges to settle, read quilt_merges before editing those files. ' +
   'If quilt_status starts with While you were away, the session changed since this folder last synced: read quilt_history for those files before editing them. ' +
   'Mentions of you (@yourname) in chat, direct messages to you and tasks handed to you wait in quilt_inbox: read it when you start, and act on each one. ' +
   'Each comes with the conversation before it with its sender; when a message refers to something earlier you do not have, read back with quilt_conversation before you answer, never guess. ' +
   'Git works here as usual: commit only the files you changed and push yourself. When the relay serves the session\'s git, your folder\'s origin is the relay: git signs in with your Quilt pass, and the relay checks each push (the session owner\'s policy, never a force-push, no ignored files) and puts it on GitHub, replayed onto GitHub\'s head if it moved (your folder follows). Otherwise your folder signs in to GitHub through Quilt (a short-lived token for this repository). Either way pushes stay within the owner\'s policy: by default branches of your own. Taking a task (quilt_move_task to doing) puts your folder on quilt/<you>/<task>; push there and Quilt opens the pull request for the task; move the task to QA when it is done and tested; Done merges the pull request once its checks pass (a person moves it to Done unless the owner lets agents push to any branch). When agents may not commit, ask a person with quilt_request_commit. ' +
-  'When a branch syncs with GitHub (quilt_branches says so), pushes and merges on GitHub come into the session by themselves; nothing goes to GitHub until someone commits and pushes. A file GitHub and the session both changed is held, and its merger proposes the merge with quilt_clash (the reviewer accepts; writing it directly is undone). Releasing a file only lets go of your claim: it publishes nothing by itself. ' +
+  'When a branch syncs with GitHub (quilt_branches says so), pushes and merges on GitHub come into the session by themselves; nothing goes to GitHub until someone commits and pushes. A file GitHub and the session both changed is merged by Quilt on its own (the newer edit stays where both changed the same lines). Releasing a file only lets go of your claim: it publishes nothing by itself. ' +
   'Work only in the session has not shipped: push before you move a task to QA. Pushes and merges on GitHub reach the session within seconds: never pull by hand. ' +
   'When you are about to answer someone in chat, quilt_typing shows them you are typing; sending clears it. ' +
   'Chat: ' + CHAT_RULES.replace(/^Send a chat message\. /, '') + ' A message that needs nothing back is settled with quilt_inbox (no_reply: [its id]), not answered. ' +
@@ -107,6 +107,7 @@ export const MCP_INSTRUCTIONS =
   'You are a member of your own in the session, apart from your person and their other AI sessions, named "<their first name> · <label>" after your work (your git branch, or what you first say you are doing); rename yourself with quilt_name_session. Your messages, inbox, claims and duties are your own. People see all of a person\'s AI sessions as one, "<person>\'s AI" ("Daniel\'s AI"): write to another person\'s AI by that name, and what is written to your person\'s AI reaches whichever of their sessions was active last (with none of them live, their cloud AI, if they connected one: Quilt runs their own AI tool for them on their own cloud VM). ' +
   'Share what you are doing with quilt_share: when you start on a request (request and your plan) and when you finish (what you did and the files you changed). Partners see it in their feed, it puts your work on the task board, and it tells the host not to commit under you. ' +
   'When Claude Code is started with the quilt channel, they arrive on their own as <channel source="quilt"> events while you work: treat each like a request from that person, answer with quilt_message, and take a task with quilt_move_task. ' +
+  RUN_GUIDE + ' ' +
   TASK_WORKFLOW
 
 export async function runMcp () {
@@ -439,39 +440,29 @@ export async function runMcp () {
     return n ? `Withdrew your request for ${rel}.` : `You had not asked for ${rel}.`
   }))
 
-  const did = (m, deleted = false) => mergeAction(m, deleted)
+  // Quilt merges on its own (session.js autoSettle): these say what it did, and what waits for a holder.
   const mergeLine = (m, me) => {
     const who = m.by === me ? 'you' : m.by
-    const other = m.others[0] ? (m.others[0] === me ? 'you' : m.others[0]) : 'the session'
-    const what = m.kind === 'ai' ? `merged by AI, waiting for a look`
-      : m.kind === 'claimed' ? `${who} ${did(m)} but ${m.claimedBy} has it claimed`
-      : m.oursDeleted ? `${who} ${did(m, true)} and ${other} changed it in the session`
-      : m.theirsHash === null ? `${who} ${did(m)} but it was deleted in the session`
-      : `${who} ${did(m)} and ${other} changed it in the session`
-    return `- \`${m.path}\` (id ${m.id}, ${m.state}): ${what}${m.reason ? ` — ${m.reason}` : ''}`
+    const what = m.state !== 'done' ? `${who} ${mergeAction(m)}; ${m.claimedBy || 'someone'} has it claimed, and it goes in, merged by Quilt, when they let go`
+      : m.reason || 'merged by Quilt'
+    return `- \`${m.path}\`: ${what}`
   }
 
   server.registerTool('quilt_merges', {
-    description: 'Files changed in two places (offline or by a pull, and in the session). Quilt never combines two different changes on its own. Each has an id. The file currently holds the session\'s version; the other version is under .quilt/merges/<id>/ours (with base and theirs beside it). To settle one yourself: write the merged file, then call quilt_resolve_merge with how "agent".',
+    description: 'What Quilt merged on its own recently: files changed in two places (offline, by a pull or on GitHub, and in the session). Quilt combines them itself; where both changed the same lines the newer edit stays and the other lines are kept in the file\'s history. Nothing here is for you to settle.',
     inputSchema: {}
   }, () => withDaemon(async (d) => {
     const { merges } = await call(d, 'GET', '/merges')
     const me = (await call(d, 'GET', '/info')).name
-    const open = merges.filter((m) => m.state !== 'done')
-    if (!open.length) return 'Nothing to merge.'
-    return `Merges to settle:\n${open.map((m) => mergeLine(m, me)).join('\n')}`
+    if (!merges.length) return 'Quilt has merged nothing lately.'
+    return `Quilt merges on its own; nothing to do:\n${merges.map((m) => mergeLine(m, me)).join('\n')}`
   }))
 
+  // Kept for guides and prompts from before Quilt merged on its own.
   server.registerTool('quilt_resolve_merge', {
-    description: 'Settle a merge from quilt_merges. how: "agent" after you wrote the merged file yourself; "mine" to keep the offline version; "theirs" to keep the session version; "review" to accept an AI merge as it is.',
-    inputSchema: {
-      id: z.string().describe('The merge id'),
-      how: z.enum(['agent', 'mine', 'theirs', 'review']).describe('How it was settled')
-    }
-  }, ({ id, how }) => withDaemon(async (d) => {
-    const r = await call(d, 'POST', '/merges/resolve', { id, how })
-    return `Settled the merge of ${r.path} (${how}).`
-  }, { gate: gateFor('quilt_resolve_merge') }))
+    description: 'Not needed any more: Quilt merges on its own. Kept so older instructions get an answer.',
+    inputSchema: { id: z.string().optional(), how: z.string().optional() }
+  }, () => ({ content: [{ type: 'text', text: 'Quilt merges on its own now: there is nothing to settle.' }] }))
 
   server.registerTool('quilt_clash', {
     description: CLASH_DESCRIPTION,
@@ -646,7 +637,7 @@ export async function runMcp () {
     description: 'Download a file someone shared in chat. Received files are normally saved automatically (see quilt_read_messages); use this to fetch one again or save it into the project.',
     inputSchema: {
       id: z.string().describe('The message id shown next to the file'),
-      dest: z.string().optional().describe('Destination path or folder inside the project (default: .quilt/inbox/)')
+      dest: z.string().optional().describe('Destination path or folder inside the project (default: the "Chat files" folder)')
     }
   }, ({ id, dest }) => withDaemon(async (d) => {
     const r = await call(d, 'POST', '/get', { id, dest: dest ? insideProject(d.dir, dest) : undefined })
@@ -961,7 +952,7 @@ export async function runMcp () {
   }, () => withDaemon(async (d) => { const r = await call(d, 'GET', '/sync-status'); return syncStatusText(r.branches || [], { mine: r.mine || '' }) }))
 
   server.registerTool('quilt_sync_branch', {
-    description: 'Bring commits made outside the session into it now: fetches this folder\'s upstream (say origin/main after a PR merged, or a push from a worktree) and moves the branch forward, with the session\'s uncommitted work merged in. Quilt also does this by itself about once a minute; call it right after you push or merge elsewhere. It says when the fetch fails (git has no credentials here, say). A folder that is not a git clone, or can\'t fetch, asks the relay to bring the commits in from GitHub instead. It never merges git history: a branch that has diverged, or files that clash with the session\'s work, become one task on the board for one AI to resolve (the others are told to leave those files to them).',
+    description: 'Bring commits made outside the session into it now: fetches this folder\'s upstream (say origin/main after a PR merged, or a push from a worktree) and moves the branch forward, with the session\'s uncommitted work merged in. Quilt also does this by itself about once a minute; call it right after you push or merge elsewhere. It says when the fetch fails (git has no credentials here, say). A folder that is not a git clone, or can\'t fetch, asks the relay to bring the commits in from GitHub instead. Files that both the commits and the session changed are merged by Quilt on its own.',
     inputSchema: {}
   }, () => withDaemon(async (d) => describeBranchSync(await call(d, 'POST', '/branches/sync'))))
 
@@ -1004,6 +995,11 @@ export async function runMcp () {
     inputSchema: {}
   }, () => withDaemon(async (d) => (await call(d, 'GET', '/rules')).text))
 
+  server.registerTool('quilt_secret_names', {
+    description: SECRET_NAMES_DESCRIPTION,
+    inputSchema: {}
+  }, () => withDaemon(async (d) => describeSecretNames({ ...(await call(d, 'GET', '/secrets/names')), hosted: false })))
+
   server.registerTool('quilt_session_info', {
     description: 'Where the shared project lives on disk, how you appear to others, who is online, and the invite link.',
     inputSchema: {}
@@ -1075,6 +1071,7 @@ export async function runMcp () {
       const notes = []
       if (f.edited && now - f.edited.ts < 10 * 60 * 1000) notes.push(`edited by ${f.edited.by === me ? 'you' : f.edited.by} ${Math.round((now - f.edited.ts) / 1000)}s ago`)
       if (f.claim) notes.push(`claimed by ${f.claim.by === me ? 'you' : f.claim.by}${f.claim.note ? `: ${f.claim.note}` : ''}${f.claim.queue && f.claim.queue.length ? `, ${f.claim.queue.length} waiting` : ''}`)
+      if (f.chat) notes.push(`sent in chat by ${f.chat.by === me ? 'you' : f.chat.by}: in your folder only, never synced or committed`)
       if (f.binary) notes.push('binary')
       return `${f.path}${notes.length ? `  [${notes.join('; ')}]` : ''}`
     })

package/src/merge3.js

@@ -1,9 +1,8 @@
 // Three-way merge of text, line by line, the way git does it: changes to
 // different lines combine on their own; the same lines changed on both sides
-// are a conflict. Quilt never uses it to combine two different changes on its
-// own (a person settles those): it writes the markers for Edit by hand, and
-// lays out a settled clash with the commits around it (relay-upstream.js).
-import { diff3Merge } from 'node-diff3'
+// are a conflict. Quilt settles those itself (mergeAuto): nobody is asked to merge
+// (docs/superpowers/specs/2026-10-18-automatic-merges.md).
+import { diff3Merge, diffIndices } from 'node-diff3'
 
 export const MARK = { start: '<<<<<<< mine', mid: '=======', end: '>>>>>>> session' }
 
@@ -121,20 +120,103 @@ export function mergeSmart (base, ours, theirs, { union = false } = {}) {
   for (const r of regions) {
     if (r.ok) { out.push(...r.ok); continue }
     const c = r.conflict
-    if (union) { out.push(...c.a, ...c.b); step('union'); continue }
-    const both = c.o.length === 0 ? addedBoth(c.a, c.b) : sameImport(c.o, c.a, c.b)
-    if (both) { out.push(...both); continue }
-    if (sameIgnoringWs(c.a, c.b)) { out.push(...c.a); step('whitespace'); continue } // the same change, spaced differently
-    if (sameIgnoringWs(c.a, c.o)) { out.push(...c.b); step('whitespace'); continue } // ours only reindented
-    if (sameIgnoringWs(c.b, c.o)) { out.push(...c.a); step('whitespace'); continue } // theirs only reindented
-    const words = mergeWords(c.o, c.a, c.b)
-    if (words) { out.push(...words); step('words'); continue }
+    const settled = ladder(c, { union })
+    if (settled) { out.push(...settled.lines); step(settled.how); continue }
     conflicts.push({ base: c.o, ours: c.a, theirs: c.b })
     out.push(...c.a)
   }
   return { text: out.join('\n'), conflicts, how }
 }
 
+/** mergeSmart's steps for one region both sides changed ({ o, a, b }): { lines, how }, or null when none settles it. */
+function ladder (c, { union = false } = {}) {
+  if (union) return { lines: [...c.a, ...c.b], how: 'union' }
+  const both = c.o.length === 0 ? addedBoth(c.a, c.b) : sameImport(c.o, c.a, c.b)
+  if (both) return { lines: both, how: 'lines' }
+  if (sameIgnoringWs(c.a, c.b)) return { lines: c.a, how: 'whitespace' } // the same change, spaced differently
+  if (sameIgnoringWs(c.a, c.o)) return { lines: c.b, how: 'whitespace' } // ours only reindented
+  if (sameIgnoringWs(c.b, c.o)) return { lines: c.a, how: 'whitespace' } // theirs only reindented
+  const words = mergeWords(c.o, c.a, c.b)
+  if (words) return { lines: words, how: 'words' }
+  return null
+}
+
+/**
+ * How Quilt combines two versions on its own: mergeSmart's steps, then each region both sides
+ * changed differently goes to the newer side (`oursNewer`). `lost` lists the lines that lost:
+ * { side: 'ours' | 'theirs', lines, kept: the lines that won, at: their first line in `text` },
+ * for the file's history and the notice to whoever wrote them.
+ */
+export function mergeAuto (base, ours, theirs, { oursNewer = false, union = false } = {}) {
+  const regions = diff3Merge(lines(ours), lines(base), lines(theirs), { excludeFalseConflicts: true })
+  const out = []
+  const lost = []
+  const newer = (a, b, at) => {
+    const [won, lose, side] = oursNewer ? [a, b, 'theirs'] : [b, a, 'ours']
+    lost.push({ side, lines: lose, kept: won, at })
+    return won
+  }
+  for (const r of regions) {
+    if (r.ok) { out.push(...r.ok); continue }
+    const c = r.conflict
+    const settled = ladder(c, { union })
+    if (settled) { out.push(...settled.lines); continue }
+    // Changes next to each other, not over each other (one side edits a line, the other adds one
+    // after it): both go in.
+    const side = sideBySide(c.o, c.a, c.b)
+    if (side) { out.push(...side); continue }
+    // The same lines on all three sides (changes next to each other): line by line, so a line only
+    // one side changed keeps that change.
+    if (c.o.length === c.a.length && c.o.length === c.b.length) {
+      for (let i = 0; i < c.o.length; i++) {
+        const [o, a, b] = [c.o[i], c.a[i], c.b[i]]
+        if (a === b || b === o) out.push(a)
+        else if (a === o) out.push(b)
+        else out.push(...newer([a], [b], out.length))
+      }
+      continue
+    }
+    out.push(...newer(c.a, c.b, out.length))
+  }
+  return { text: out.join('\n'), lost }
+}
+
+/** Whether two hunks (one per side) change the same base lines, or one adds lines inside the other's. */
+function overlaps (x, y) {
+  if (x.len && y.len) return x.at < y.at + y.len && y.at < x.at + x.len
+  if (!x.len && !y.len) return x.at === y.at // both add at one place: which goes first would be a guess
+  const [add, change] = x.len ? [y, x] : [x, y]
+  return add.at > change.at && add.at < change.at + change.len
+}
+
+/**
+ * One region both sides changed, when their edits only touch: each side's edits from base
+ * (diffIndices hunks) are applied together, in base order, when no base line is changed by both,
+ * and no line is added where the other side changes lines. Returns the lines, or null.
+ */
+function sideBySide (o, a, b) {
+  const hunks = [
+    ...diffIndices(o, a).map((h) => ({ at: h.buffer1[0], len: h.buffer1[1], lines: h.buffer2Content, side: 0 })),
+    ...diffIndices(o, b).map((h) => ({ at: h.buffer1[0], len: h.buffer1[1], lines: h.buffer2Content, side: 1 }))
+  ].sort((x, y) => x.at - y.at || x.len - y.len || x.side - y.side)
+  for (let i = 0; i < hunks.length; i++) {
+    for (let j = i + 1; j < hunks.length; j++) {
+      const [x, y] = [hunks[i], hunks[j]]
+      if (x.side === y.side) continue
+      if (overlaps(x, y)) return null
+    }
+  }
+  const out = []
+  let pos = 0
+  for (const h of hunks) {
+    out.push(...o.slice(pos, h.at))
+    out.push(...h.lines)
+    pos = Math.max(pos, h.at + h.len)
+  }
+  out.push(...o.slice(pos))
+  return out
+}
+
 /** The paths a .gitattributes text marks merge=union, as a matcher: (rel) => boolean. */
 export function unionMatcher (texts) {
   const patterns = []

package/src/pass-source.js

@@ -165,12 +165,19 @@ export function agentPasses ({ name, dir, fetch: fetchImpl = globalThis.fetch, n
  * this computer's account. `name` is the name saved on this computer, so a
  * session can start before (or without, when offline) its first pass.
  */
+/** The accounts API as this computer's account, signed in now (a sign-in since is picked up). */
+export async function personApiAuth () {
+  const account = readAccount()
+  if (!account) throw new Error(NOT_SIGNED_IN)
+  return { api: apiUrl(), token: account.token }
+}
+
 export function sessionPasses ({ agent = null, dir } = {}) {
   if (agent) {
     const saved = readAgent({ name: agent, dir })
-    return { passes: agentPasses({ name: agent, dir }), identity: saved.identity, kind: 'agent', name: saved.name || agent }
+    return { passes: agentPasses({ name: agent, dir }), identity: saved.identity, kind: 'agent', name: saved.name || agent, apiAuth: async () => { const s = await agentAccess({ name: agent, dir }); return { api: s.api, token: s.accessKey } } }
   }
   const account = readAccount()
   if (!account) throw new Error(NOT_SIGNED_IN)
-  return { passes: personPasses({ token: account.token }), identity: null, kind: 'human', name: account.account.name || null }
+  return { passes: personPasses({ token: account.token }), identity: null, kind: 'human', name: account.account.name || null, apiAuth: personApiAuth }
 }

package/src/pathrules.js

@@ -9,11 +9,18 @@ export const LARGE_FILE_BYTES = 256 * 1024
 // The most a stored file may be (the relay may allow less).
 export const MAX_STORED_BINARY_BYTES = 100 * 1024 * 1024
 
+/**
+ * Where each person's app saves the files sent in the session's chat (session.js): only those
+ * who can see the message get the file, so the folder is never synced, committed or pushed.
+ */
+export const CHAT_FILES = 'Chat files'
+
 // Never synced, regardless of .gitignore. .env files are excluded so secrets
 // stay on each person's machine; Claude Code worktrees are whole private
 // copies of the project.
 export const ALWAYS_IGNORED = [
   '.git', '.quilt', '.cowove', 'node_modules', '.DS_Store', 'Thumbs.db', '.claude/worktrees',
+  `/${CHAT_FILES}`,
   // Each person's own Claude Code settings (permissions, Quilt's hooks) stay on their machine.
   '.claude/settings.local.json',
   // Build output and caches: large, machine-specific, and rebuilt by each person.