heyquilt 0.3.116 → 0.3.118

package/RELEASES.md

@@ -11,8 +11,25 @@ Format: `## <version> — <YYYY-MM-DD>`, an optional one-line summary, then bull
 Lead each bullet with a short bold phrase. Inline `code` and **bold** are rendered;
 nothing else is.
 
+## 0.3.118 — 2026-10-25
+
+- **A new name for your AI shows at once.** Renaming your cloud AI (or changing its color) now makes it join its sessions again under the new name within seconds, once it isn't in the middle of a run, so @its new name reaches it. Before, it kept its old name for up to five minutes and then dropped out of the session's people list.
+- **Your AI answers while it works on a task.** A message to your cloud AI no longer waits behind a task it is working on (up to half an hour): it answers right away, changing no files while the task runs, and if you ask for more work it says it will do it next or adds it to the board.
+0.3.117 did not finish publishing, so this release carries it.
+
+- **Your AI is no longer held back when it finishes.** The AI sessions on your computer (Claude Code, Cursor, Gemini CLI) no longer get Quilt's hook as they finish a turn, which could send them back to work with messages that were for you. Quilt takes out the one it wrote earlier the next time a session starts. Files they edited are let go when their session ends, or after 20 quiet minutes. Agents that joined as their own members, your cloud AI among them, keep it: they still answer what is written to them before they stop.
+
+## 0.3.117 — 2026-10-25
+
+- **Your AI is no longer held back when it finishes.** The AI sessions on your computer (Claude Code, Cursor, Gemini CLI) no longer get Quilt's hook as they finish a turn, which could send them back to work with messages that were for you. Quilt takes out the one it wrote earlier the next time a session starts. Files they edited are let go when their session ends, or after 20 quiet minutes. Agents that joined as their own members, your cloud AI among them, keep it: they still answer what is written to them before they stop.
+
 ## 0.3.116 — 2026-10-25
 
+- **Set up your AI, step by step.** Settings → Agents invites you to give your AI a seat in your sessions; setting it up takes over Settings (the pop-up from a session, or the Settings page) as five steps: its name and color, which AI it runs on (Claude Code, Codex or Cursor, the model and a daily limit), what it may do, which sessions it works in, then your tool's own sign-in. Its card fills in as you answer, and you can change every answer later from its card.
+- **Your AI can have its own name.** Call it Juniper, Atlas or anything you like: people see it as Juniper with a "Daniel's AI" tag, and both @Juniper and @Daniel's AI reach it. Messages to it stay yours to read, also while it sleeps.
+- **Decide what your AI does.** It always answers people who write to it. You choose whether it picks up tasks (only when you ask, the ones assigned to it, or any open task, one after another), whether it changes files and pushes branches of its own, and whether every message wakes its machine (off: messages wait for its next wake, for a task or when you work in one of its sessions). House rules go with every run.
+- **Choose where your AI works.** Every session you join, only the ones you pick, or none for now; picking fewer makes it leave the others.
+- **Settings: the AI on this computer.** Its card no longer has "pick up tasks by itself": the AI on your computer works on what you ask it, and tasks for your AI are your cloud AI's.
 - **Source control has its own command, `seam`.** Quilt Source's git verbs (`seam log`, `seam merge`, `seam checkout`…) now come from their own package, `@heyquilt/seam`, with their own sign-in (`seam login`) and their own MCP server (`seam mcp`, tools named `seam_*`). The Quilt app's `quilt` command and Quilt's MCP no longer carry source control: Quilt sessions and Quilt Source are separate products. Block folders now hold `.seam/block.json`, and agents give seam their key with `SEAM_TOKEN`. The docs at frame.heyquilt.com say the same.
 
 ## 0.3.115 — 2026-10-25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyquilt",
-  "version": "0.3.116",
+  "version": "0.3.118",
   "description": "Real-time, tool-agnostic pair vibe coding: sync a project folder live between collaborators using any AI coding tool.",
   "author": {
     "name": "Daniel Carmichael",

package/src/account.js

@@ -580,10 +580,10 @@ export async function aiVmStatus ({ token, wait, api = apiUrl(), fetch: fetchImp
 }
 
 /** Connects a cloud AI running `tool` (Claude Code, Codex or Cursor): starts its machine. */
-export async function aiVmConnect ({ token, tool, api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
-  return call(fetchImpl, api, 'POST', '/v1/me/ai-vm', { tool }, token)
+export async function aiVmConnect ({ token, tool, setup = {}, api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
+  return call(fetchImpl, api, 'POST', '/v1/me/ai-vm', { ...setup, tool }, token)
 }
-/** Changes the cloud AI's settings: `patch` is any of { tool, model, prompt, cap }. */
+/** Changes the cloud AI's settings: `patch` is any of { tool, model, prompt, cap, name, color, tasks, files, wake, sessionsMode, rooms }. */
 export async function aiVmUpdate ({ token, patch, api = apiUrl(), fetch: fetchImpl = globalThis.fetch }) {
   return call(fetchImpl, api, 'PATCH', '/v1/me/ai-vm', patch, token)
 }

package/src/ai-vm.js

@@ -352,6 +352,9 @@ export class AiVm {
     this.apiOkAt = this.now()
     if (this.stopped) return n
     const changedTool = !this.config || this.config.tool !== n.config.tool
+    // A new name or color (its person changed its setup): it joins its sessions again as that, once
+    // nothing runs. A connection keeps the name it joined with; the relay drops a presence under another.
+    if (this.config && (this.config.name !== n.config.name || this.config.color !== n.config.color)) this.reidentify = true
     this.applyConfig(n.config)
     const busy = n.signIn || n.code || n.follow.length || n.leave.length
     if (busy) this.lastActivity = this.now()
@@ -366,13 +369,32 @@ export class AiVm {
     for (const link of n.follow) await this.follow(link).catch((err) => this.log(`could not join: ${err.message}`))
     for (const room of n.leave) await this.leave(room).catch((err) => this.log(`could not leave ${room}: ${err.message}`))
     if (busy || changedTool) await this.report().catch(() => {})
+    await this.reidentifyIfIdle()
     return n
   }
 
+  /** Joins every session again under its new name and color, when it has one and nothing runs. */
+  async reidentifyIfIdle () {
+    if (!this.reidentify || this.stopped || await this.busy()) return []
+    this.reidentify = false
+    const again = []
+    for (const [room, link] of Object.entries(this.followed())) {
+      const r = this.runs.get(room)
+      if (!r) continue
+      this.log(`[${room}] joining again as ${(this.config && this.config.name) || 'its new self'}`)
+      this.runs.delete(room)
+      await r.run.stop().catch(() => {})
+      try { await this.follow(link); again.push(room) } catch (err) { this.log(`could not rejoin ${room}: ${err.message}`) }
+    }
+    return again
+  }
+
   /** The person's settings, as this machine's own "Work on its own" settings. */
   applyConfig (c) {
     this.config = c
-    saveSettings({ tool: c.tool, autoWork: 'auto', autoFiles: true, autoModel: c.model || undefined, autoCap: c.cap || undefined, autoPrompt: c.prompt || undefined })
+    // What its person chose it does: which tasks it takes by itself, and whether it changes files.
+    const tasks = { asked: 'off', mine: 'mine', any: 'any' }[c.tasks] || 'mine'
+    saveSettings({ tool: c.tool, autoWork: 'auto', autoFiles: c.files !== false, aiTasks: tasks, autoModel: c.model || undefined, autoCap: c.cap || undefined, autoPrompt: c.prompt || undefined })
   }
 
   // ------------------------------------------------------------- sign-in --
@@ -500,6 +522,7 @@ export class AiVm {
       conn: { server: invite.relay || relayUrl(), room, secret: invite.secret },
       name: auth.name,
       tool: (this.config && this.config.tool) || 'Quilt cloud AI',
+      ...(this.config && this.config.color ? { color: this.config.color } : {}),
       kind: 'agent',
       passes: auth.passes,
       identity: auth.identity,
@@ -527,6 +550,7 @@ export class AiVm {
    */
   async rejoinCheck () {
     if (this.stopped) return []
+    await this.reidentifyIfIdle()
     const now = this.now()
     const apiUp = this.apiOkAt && now - this.apiOkAt < this.rejoinMs
     const again = []
@@ -579,7 +603,7 @@ export class AiVm {
   async busy () {
     if (this.signing) return true
     const work = await this.autowork()
-    return !!(work.running || (work.queue && work.queue.length))
+    return !!(work.running || work.talking || (work.queue && work.queue.length) || (work.talkQueue && work.talkQueue.length))
   }
 
   /**

package/src/api/memory-store.js

@@ -1090,10 +1090,10 @@ export function createMemoryStore ({ now = Date.now } = {}) {
     async deleteAgentWebhook (agentId) { return agentWebhooks.delete(agentId) },
 
     // A person's cloud AI machine (see 20261017000000_ai_vms.sql): one per person.
-    async createAiVm ({ userId, tool, model = '', prompt = '', cap = 0, region = '' }) {
+    async createAiVm ({ userId, tool, model = '', prompt = '', cap = 0, region = '', name = '', color = '', tasks = 'mine', files = true, wake = true, sessionsMode = 'every', rooms = [] }) {
       if (!profiles.has(userId)) throw fkViolation('person', 'does not exist')
       if (aiVms.has(userId)) throw duplicate('cloud AI machine')
-      const row = { userId, tool, model, prompt, cap, agentId: null, inviteId: null, machineId: null, volumeId: null, region, state: 'creating', error: '', signedIn: false, usageToday: {}, sessions: [], lastReportAt: null, createdAt: now(), updatedAt: now() }
+      const row = { userId, tool, model, prompt, cap, name, color, tasks, files, wake, sessionsMode, rooms: structuredClone(rooms), agentId: null, inviteId: null, machineId: null, volumeId: null, region, state: 'creating', error: '', signedIn: false, usageToday: {}, sessions: [], lastReportAt: null, createdAt: now(), updatedAt: now() }
       aiVms.set(userId, row); return copy(row)
     },
     async aiVmOf (userId) { return copy(aiVms.get(userId)) },

package/src/api/routes/ai-vm.js

@@ -15,6 +15,14 @@ import { isHostedRelay, HOSTED_RELAY } from '../../settings.js'
 import { autoToolFor } from '../../autowork-tools.js'
 
 export const AI_VM_TOOLS = ['Claude Code', 'Codex', 'Cursor']
+// Which tasks it takes by itself: only when asked, those assigned to it, or any open one.
+export const AI_VM_TASKS = ['asked', 'mine', 'any']
+// Which of its person's sessions it joins: every one they join, the rooms picked, or none.
+export const AI_VM_SESSIONS = ['every', 'pick', 'none']
+// Its own name: letters, digits, spaces and . ' - (1 to 40); blank is "<person>'s AI".
+const AI_NAME = /^[\p{L}\p{N}][\p{L}\p{N} .'’-]{0,39}$/u
+const COLOR = /^#[0-9a-fA-F]{6}$/
+const RESERVED_NAMES = ['quilt', 'agents', 'everyone', 'the relay']
 // The machine reports about once a minute; one not heard from for this long may have stopped.
 const QUIET_MS = 3 * 60 * 1000
 // How long a waiting GET is held before it answers with nothing new.
@@ -191,6 +199,7 @@ export function aiVmRoutes ({ store, person, agentAuth, bearer, now, apiUrl, log
   }
 
   const needFly = () => { if (!fly) throw new HttpError(503, "Cloud AI isn't set up on this server.") }
+  const personName = async (userId) => { const p = await store.profile(userId); return String((p && p.name) || '') }
   async function mine (req) {
     const u = await person(req)
     const vm = await store.aiVmOf(u.userId)
@@ -203,6 +212,14 @@ export function aiVmRoutes ({ store, person, agentAuth, bearer, now, apiUrl, log
     const l = liveOf(vm.userId)
     return {
       tool: vm.tool,
+      // Its own name and color ('' : "<person>'s AI", a color of its own), and what it does.
+      aiName: vm.name || '',
+      color: vm.color || '',
+      tasks: vm.tasks || 'mine',
+      files: vm.files !== false,
+      wake: vm.wake !== false,
+      sessionsMode: vm.sessionsMode || 'every',
+      rooms: Array.isArray(vm.rooms) ? vm.rooms : [],
       model: vm.model,
       models: autoToolFor(vm.tool)?.models || [],
       prompt: vm.prompt,
@@ -270,8 +287,44 @@ export function aiVmRoutes ({ store, person, agentAuth, bearer, now, apiUrl, log
   // `config`: the settings changed since the machine last asked (a new tool signs in at once).
   const pendingFor = (f) => f.follow.length || f.leave.length || f.signIn || f.code !== null || f.config
 
-  function cleanSettings (b, vm) {
+  /** Whether the person's cloud AI joins `room`, by the sessions they chose for it. */
+  const joins = (vm, room) => {
+    const mode = vm.sessionsMode || 'every'
+    return mode === 'every' || (mode === 'pick' && (vm.rooms || []).includes(room))
+  }
+
+  /** `vm`: the record as it is ({} for a new one); `person`: their name, which the AI's may not be. */
+  function cleanSettings (b, vm, person = '') {
     const out = {}
+    if (b.name !== undefined) {
+      const name = String(b.name).trim().replace(/\s+/g, ' ')
+      if (name && !AI_NAME.test(name)) throw new HttpError(400, "Your AI's name: up to 40 letters, numbers and spaces.")
+      const low = name.toLowerCase()
+      if (name && (RESERVED_NAMES.includes(low) || low === String(person).trim().toLowerCase())) throw new HttpError(400, `"${name}" is taken: pick another name for your AI.`)
+      // "<person>'s AI" is the name it has anyway: kept blank, so it follows a new name of theirs.
+      out.name = person && name === `${String(person).trim()}'s AI` ? '' : name
+    }
+    if (b.color !== undefined) {
+      if (b.color !== '' && !COLOR.test(String(b.color))) throw new HttpError(400, 'color: #rrggbb')
+      out.color = String(b.color)
+    }
+    if (b.tasks !== undefined) {
+      if (!AI_VM_TASKS.includes(b.tasks)) throw new HttpError(400, `tasks is one of ${AI_VM_TASKS.join(', ')}`)
+      out.tasks = b.tasks
+    }
+    for (const k of ['files', 'wake']) {
+      if (b[k] === undefined) continue
+      if (typeof b[k] !== 'boolean') throw new HttpError(400, `${k}: true or false`)
+      out[k] = b[k]
+    }
+    if (b.sessionsMode !== undefined) {
+      if (!AI_VM_SESSIONS.includes(b.sessionsMode)) throw new HttpError(400, `sessionsMode is one of ${AI_VM_SESSIONS.join(', ')}`)
+      out.sessionsMode = b.sessionsMode
+    }
+    if (b.rooms !== undefined) {
+      if (!Array.isArray(b.rooms) || b.rooms.length > 200 || !b.rooms.every((r) => ROOM.test(String(r)))) throw new HttpError(400, 'rooms: session names')
+      out.rooms = [...new Set(b.rooms.map(String))]
+    }
     if (b.tool !== undefined) {
       if (!AI_VM_TOOLS.includes(b.tool)) throw new HttpError(400, `tool is one of ${AI_VM_TOOLS.join(', ')}`)
       // A new tool signs in again and starts from its own models.
@@ -312,10 +365,12 @@ export function aiVmRoutes ({ store, person, agentAuth, bearer, now, apiUrl, log
       limit(req)
       if (!AI_VM_TOOLS.includes(body.tool)) throw new HttpError(400, `tool is one of ${AI_VM_TOOLS.join(', ')}`)
       if (await store.aiVmOf(u.userId)) throw new HttpError(409, 'You already have a cloud AI. Disconnect it first.')
+      // What the person chose while setting it up: its name, color, model, rules, what it does, where.
+      const { tool: _tool, signedIn: _s, ...setup } = cleanSettings(body, { tool: body.tool }, await personName(u.userId))
       // The machine joins as the person's agent with a one-time link, so its keys are made there.
       const token = newToken('qj_')
       const invite = await store.createAgentInvite({ tokenHash: hashToken(token), ownerUserId: u.userId, createdBy: u.userId, expiresAt: now() + AGENT_INVITE_TTL_MS })
-      let vm = await store.createAiVm({ userId: u.userId, tool: body.tool, region: fly.region })
+      let vm = await store.createAiVm({ ...setup, userId: u.userId, tool: body.tool, region: fly.region })
       vm = await store.updateAiVm(u.userId, { inviteId: invite.id })
       try {
         const m = await machineFor(u.userId, { QUILT_API: apiUrl, QUILT_AI_VM_JOIN: `${apiUrl}/v1/join/${token}`, HOME: '/data/home' })
@@ -333,9 +388,15 @@ export function aiVmRoutes ({ store, person, agentAuth, bearer, now, apiUrl, log
 
     ['PATCH', /^\/v1\/me\/ai-vm$/, async (req, body) => {
       const { u, vm } = await mine(req)
-      const patch = cleanSettings(body, vm)
+      const patch = cleanSettings(body, vm, await personName(u.userId))
       if (!Object.keys(patch).length) return view(vm)
       let up = await store.updateAiVm(u.userId, patch)
+      // Sessions it may no longer be in: it leaves them (it joins the newly picked ones as the app hands them over).
+      if (patch.sessionsMode !== undefined || patch.rooms !== undefined) {
+        const f = liveOf(u.userId).forVm
+        for (const x of up.sessions || []) if (!joins(up, x.room) && !f.leave.includes(x.room)) f.leave = [...f.leave, x.room].slice(-MAX_PENDING)
+        f.follow = f.follow.filter((l) => joins(up, parseInvite(l, { allowRelay: () => true }).room))
+      }
       liveOf(u.userId).forVm.config = true
       // A new tool's sign-in starts over: the old tool's link and code are not shown for it.
       if (patch.tool) liveOf(u.userId).signIn = { step: 'starting', url: '', code: '', needsCode: false, error: '' }
@@ -377,6 +438,8 @@ export function aiVmRoutes ({ store, person, agentAuth, bearer, now, apiUrl, log
         let invite
         try { invite = parseInvite(String(body.link || ''), { allowRelay: (s) => isHostedRelay(s) || String(s).replace(/\/+$/, '') === ownRelay }) } catch { throw new HttpError(400, "link must be a Quilt session's invite link") }
         if (!invite.secret) throw new HttpError(400, "link must be a Quilt session's invite link")
+        // A session its person didn't choose for it: not joined (its app hands over every session).
+        if (!joins(vm, invite.room)) return { ok: true, joins: false }
         const link = buildInvite({ server: invite.relay || HOSTED_RELAY, room: invite.room, secret: invite.secret }, isHostedRelay)
         f.leave = f.leave.filter((r) => r !== invite.room)
         f.follow = [...f.follow.filter((l) => parseInvite(l, { allowRelay: () => true }).room !== invite.room), link].slice(-MAX_PENDING)
@@ -411,7 +474,7 @@ export function aiVmRoutes ({ store, person, agentAuth, bearer, now, apiUrl, log
       const fresh = (await store.aiVmOf(vm.userId)) || vm
       const p = await store.profile(vm.userId)
       const out = {
-        config: { tool: fresh.tool, model: fresh.model, prompt: fresh.prompt, cap: fresh.cap, person: (p && p.name) || 'Quilt user' },
+        config: { tool: fresh.tool, model: fresh.model, prompt: fresh.prompt, cap: fresh.cap, person: (p && p.name) || 'Quilt user', name: fresh.name || '', color: fresh.color || '', tasks: fresh.tasks || 'mine', files: fresh.files !== false },
         follow: f.follow,
         leave: f.leave,
         signIn: f.signIn,
@@ -491,6 +554,9 @@ export function aiVmRoutes ({ store, person, agentAuth, bearer, now, apiUrl, log
       const agent = UUID.test(agentId) ? await store.agentById(agentId) : null
       const vm = agent && !agent.revokedAt ? await cloudAiOf(store, agent) : null
       if (!vm) throw new HttpError(404, 'no such cloud AI')
+      // Its person turned "Wake for every message" off: a message waits for its next wake (a task,
+      // or its person at work in the session). An older relay says no `why`: it wakes, as before.
+      if (vm.wake === false && body.why === 'message') return { ok: true, asleep: true }
       const last = relayWokeAt.get(agentId) || 0
       if (now() - last < RELAY_WAKE_MS) return { ok: true, already: true }
       relayWokeAt.set(agentId, now())

package/src/api/server.js

@@ -152,9 +152,9 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
   }
 
   /**
-   * Who a pass for an agent is for. A person's cloud AI (routes/ai-vm.js) is that
-   * person's AI: named "<person>'s AI" ("Dan's AI"), with its person's account (`of`) and name
-   * (`ofName`), which the relay lets in where its person stands.
+   * Who a pass for an agent is for. A person's cloud AI (routes/ai-vm.js) is that person's AI:
+   * named what they called it ("Juniper"), or "<person>'s AI" ("Dan's AI"), with its person's
+   * account (`of`) and name (`ofName`), which the relay lets in where its person stands.
    */
   async function agentHolder (agent) {
     const holder = { sub: agent.id, kind: 'agent', name: agent.name.slice(0, 64), key: agent.publicKey || '' }
@@ -162,7 +162,7 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
     if (!vm) return holder
     const p = await store.profile(vm.userId)
     const person = String((p && p.name) || 'Quilt user').slice(0, 64)
-    return { ...holder, name: aiName(person.slice(0, 58)), of: `person:${vm.userId}`, ofName: person }
+    return { ...holder, name: vm.name || aiName(person.slice(0, 58)), of: `person:${vm.userId}`, ofName: person }
   }
 
   // Resume signatures seen in the last window, so a copied one can't be used again: here, and in

package/src/api/supabase-store.js

@@ -38,7 +38,7 @@ const AGENT_PLACEMENT = 'agent_id, reach, workspace_ids, sessions, access, scope
 const WORKSPACE_AGENT_OVERRIDE = 'workspace_id, agent_id, sessions, excluded'
 const SESSION_AGENT_EXCLUSION = 'room, agent_id, excluded_by, created_at'
 const AGENT_WEBHOOK = 'agent_id, url, secret, created_at, updated_at'
-const AI_VM = 'user_id, tool, model, prompt, cap, agent_id, invite_id, machine_id, volume_id, region, state, error, signed_in, usage_today, sessions, last_report_at, created_at, updated_at'
+const AI_VM = 'user_id, tool, model, prompt, cap, name, color, tasks, files, wake, sessions_mode, rooms, agent_id, invite_id, machine_id, volume_id, region, state, error, signed_in, usage_today, sessions, last_report_at, created_at, updated_at'
 const RELAY_MACHINE = 'id, region, capacity, state, dedicated_room, load, hot_at, over_at, empty_at, hello_at, reported_at, created_at'
 const RELAY_ROOM = 'room, machine_id, state, stats, busy_minutes, heavy, placed_at, reported_at, moved_at'
 const RELAY_JOB = 'key, state, detail, started_at, finished_at'
@@ -564,8 +564,8 @@ export function createSupabaseStore ({ url, serviceKey, client }) {
     },
 
     // A person's cloud AI machine (see 20261017000000_ai_vms.sql): one per person.
-    async createAiVm ({ userId, tool, model = '', prompt = '', cap = 0, region = '' }) {
-      return rowFrom(await one(db.from('ai_vms').insert({ user_id: userId, tool, model, prompt, cap, region }).select(AI_VM).single()))
+    async createAiVm ({ userId, tool, model = '', prompt = '', cap = 0, region = '', ...setup }) {
+      return rowFrom(await one(db.from('ai_vms').insert({ user_id: userId, tool, model, prompt, cap, region, ...toSnake(setup) }).select(AI_VM).single()))
     },
     async aiVmOf (userId) { return rowFrom(await one(db.from('ai_vms').select(AI_VM).eq('user_id', userId).maybeSingle())) },
     async aiVmByAgent (agentId) { return agentId ? rowFrom(await one(db.from('ai_vms').select(AI_VM).eq('agent_id', agentId).maybeSingle())) : null },

package/src/autowork.js

@@ -13,6 +13,7 @@ import { spawn } from 'node:child_process'
 import { getSettings } from './settings.js'
 import { quiltHome } from './legacy.js'
 import { autoToolFor, findExe } from './autowork-tools.js'
+import { nextTask } from './tasks.js'
 import { claudeCli, installedEditors, openIn } from './editors.js'
 
 export const AUTO_MODES = ['chat', 'open', 'auto']
@@ -67,7 +68,7 @@ export function tokensOn (entries, ts) {
  * machine's caveman mode (CAVEMAN_DEFAULT_MODE on a cloud AI machine, vm/Dockerfile), said
  * here too so every tool talks that way, not only those whose own hooks turn it on.
  */
-export function runPrompt ({ person, job, changeFiles, prompt = '', voice = process.env.CAVEMAN_DEFAULT_MODE || '' }) {
+export function runPrompt ({ person, job, changeFiles, prompt = '', voice = process.env.CAVEMAN_DEFAULT_MODE || '', busyWith = '' }) {
   const lines = [
     `You are ${person}'s AI in the Quilt session in this folder, working on your own: nobody is watching this chat, and it isn't a conversation.`,
     ''
@@ -85,7 +86,8 @@ export function runPrompt ({ person, job, changeFiles, prompt = '', voice = proc
   if (prompt) lines.push('', `${person}'s own instructions for you:`, prompt)
   if (/^[a-z]+$/.test(voice) && voice !== 'off') lines.push('', `Talk in ${voice} mode (the caveman skill): terse, like a smart caveman, in chat, comments and notes. Code, commands, paths, commit messages and error text stay exact.`)
   lines.push('', 'Before your first change, read the project\'s rules with quilt_project_rules.')
-  if (!changeFiles) lines.push(`${person} hasn't let you change files: read, plan, comment on the task (quilt_comment_task) or ask, and leave the changes to a person or another session.`)
+  if (busyWith) lines.push(`Another run of yours is working on "${busyWith}" in this folder right now, so change no files here: answer now, and if they ask for work, say you'll do it once that is done, or add it to the board with quilt_add_task.`)
+  else if (!changeFiles) lines.push(`${person} hasn't let you change files: read, plan, comment on the task (quilt_comment_task) or ask, and leave the changes to a person or another session.`)
   lines.push(
     'If you need an answer from someone, ask them with quilt_message and stop: when they reply, this chat continues with their answer.',
     'When you finish, or stop to wait, end with a sentence or two on where things stand.'
@@ -137,8 +139,14 @@ export class AutoWork {
     this.now = now
     this.queue = []
     this.running = null
+    // Messages have a lane of their own, so a long task doesn't keep people waiting for an answer:
+    // one run there at a time too, changing no files while a task runs (two runs, one folder).
+    this.talkQueue = []
+    this.talking = null
+    this.talkIdle = Promise.resolve()
     this.idle = Promise.resolve()
     this.sessions = new Set()
+    this.tookTasks = new Set() // '<room> <task>' taken from the board by itself (takeNextTask)
     this.chats = this.loadChats()
     this.toldCap = ''
   }
@@ -179,6 +187,9 @@ export class AutoWork {
       // Their cloud AI, when it is in the session, takes it instead of this computer.
       // A task marked "not for auto pickup" waits for a person to start it, even given to the AI.
       if (e.kind === 'task' && e.task?.noPickup) continue
+      // A cloud AI its person set to take tasks only when asked leaves a task handed to it on the board
+      // (a machine set up before that choice existed has none saved: it takes them, as before).
+      if (e.kind === 'task' && session.aiOf && this.settings().aiTasks === 'off') continue
       if (e.kind === 'task' && session.forMyAi(e) && !session.leadPersona() && !this.leaveToCloud(session)) {
         if (this.queue.some((j) => j.kind === 'task' && j.id === e.task.id) || (this.running && this.running.job.id === e.task.id)) continue
         this.enqueue({ kind: 'task', session, id: e.task.id, title: e.task.title, by: e.by })
@@ -192,10 +203,12 @@ export class AutoWork {
       }
       // A person's cloud AI answers what is written to it (its inbox only has it while no AI session of theirs is live).
       if (session.aiOf && (e.kind === 'dm' || e.kind === 'mention') && !e.queue && !e.commit && !e.nudge && session.forMyAi(e)) {
-        if (this.queue.some((j) => j.kind === 'message' && j.id === e.id)) continue
+        if ([...this.queue, ...this.talkQueue].some((j) => j.kind === 'message' && j.id === e.id) || (this.talking && this.talking.job.id === e.id)) continue
         this.enqueue({ kind: 'message', session, id: e.id, title: `message from ${e.by}`, by: e.by, text: e.text })
       }
     }
+    // Idle, and allowed any open task: the board's next one.
+    if (!this.running) this.takeNextTask(session)
   }
 
   /** Whether work for the person's AI is their cloud AI's, not this computer's: it is in the session, or they have one. */
@@ -226,20 +239,55 @@ export class AutoWork {
   }
 
   enqueue (job) {
+    // A message, or a reply to one, is talk; a reply to a task's run carries that run on, in its lane.
+    if (job.kind === 'message' || (job.kind === 'reply' && job.run && job.run.kind === 'message')) {
+      this.talkQueue.push(job)
+      this.talkIdle = this.talkIdle.then(() => this.nextTalk()).catch(() => {})
+      return this.talkIdle
+    }
     this.queue.push(job)
     this.idle = this.idle.then(() => this.next()).catch(() => {})
     return this.idle
   }
 
   async next () {
+    // An answer that may change files (no task was running when it started) finishes first.
+    while (this.talking && !this.talking.readOnly) await this.talking.done
     const job = this.queue.shift()
     if (!job) return
     this.running = { job }
     try { await this.run(job) } finally { this.running = null }
+    this.takeNextTask(job.session)
+  }
+
+  async nextTalk () {
+    const job = this.talkQueue.shift()
+    if (!job) return
+    // While a task runs in this folder, the answer changes no files.
+    const busyWith = this.running && this.running.job.session === job.session ? (this.running.job.title || 'a task') : ''
+    let finished
+    this.talking = { job, readOnly: !!busyWith, done: new Promise((resolve) => { finished = resolve }) }
+    try { await this.run(job, { busyWith }) } finally { this.talking = null; finished() }
+  }
+
+  /**
+   * A cloud AI that may take any open task: with nothing else to do, the next one on the board
+   * (assigned to it first, then unassigned; tasks.js nextTask picks it, as for every AI).
+   */
+  takeNextTask (session) {
+    if (!session || !session.aiOf || this.queue.length || !this.on()) return
+    if (this.settings().aiTasks !== 'any') return
+    let next = null
+    try { next = nextTask(session.taskList().filter((t) => !this.tookTasks.has(`${session.room} ${t.id}`)), { name: session.name, asAi: false }, 'any') } catch { return }
+    if (!next) return
+    // Each once: a run that left it where it was (it couldn't, or chose not to) doesn't start over and over.
+    this.tookTasks.add(`${session.room} ${next.id}`)
+    if (this.tookTasks.size > 500) this.tookTasks.delete(this.tookTasks.values().next().value)
+    this.enqueue({ kind: 'task', session, id: next.id, title: next.title, by: next.by || '' })
   }
 
   /** Runs one piece of work to its end (or its question). */
-  async run (job) {
+  async run (job, { busyWith = '' } = {}) {
     const { session } = job
     const c = this.config()
     if (session.stopped) this.sessions.delete(session)
@@ -257,14 +305,14 @@ export class AutoWork {
     let run = job.kind === 'reply' ? job.run : null
     const resumes = p.resumes !== false && !!(run && run.chatId)
     if (!run) {
-      const prompt = runPrompt({ person: personOf(session), job, changeFiles: c.changeFiles, prompt: c.prompt })
+      const prompt = runPrompt({ person: personOf(session), job, changeFiles: c.changeFiles, prompt: c.prompt, busyWith })
       run = { id: crypto.randomBytes(6).toString('hex'), via: `auto${crypto.randomBytes(6).toString('hex')}`, room: session.room, dir: session.root, tool: p.tool, kind: job.kind, work: job.id, path: job.path || '', title: job.title, by: job.by, prompt, chatId: p.newChatId(), said: [], ts: this.now() }
     }
     if (!exe) {
       this.fail(session, run, `${p.exe} isn't installed on this computer`)
       return
     }
-    const o = { model: c.model, changeFiles: c.changeFiles, chatId: run.chatId }
+    const o = { model: c.model, changeFiles: c.changeFiles && !busyWith, chatId: run.chatId }
     const args = resumes
       ? p.resume({ ...o, prompt: replyPrompt({ run, reply: job.reply, resumes: true }) })
       : p.start({ ...o, prompt: job.kind === 'reply' ? replyPrompt({ run, reply: job.reply, resumes: false }) : run.prompt })

package/src/hooks.js

@@ -39,7 +39,12 @@ export const HOOK_COMMAND = 'quilt hook' // what older versions wrote
 export const hookCommand = (dialect = '') => quiltShellCommand(dialect ? ['hook', dialect] : ['hook'])
 /** Is this hook entry one of Quilt's (any version, any tool)? */
 export const isQuiltHook = (h) => !!h && typeof h.command === 'string' && (h.command.startsWith(HOOK_COMMAND) || /(quilt\.js|\/quilt)"? hook( \w+)?$/.test(h.command))
-export function hookSettings (command = hookCommand()) {
+/**
+ * `stop`: the hook as the AI finishes a turn, for an agent of its own (it is held there to answer
+ * what is written to it and to hand on files someone waits for). A person's AI sessions get none:
+ * nothing written to the person is theirs to answer, and their claims go when the session ends.
+ */
+export function hookSettings (command = hookCommand(), { stop = true } = {}) {
   const run = { type: 'command', command, timeout: 10 }
   const edits = [...CLAUDE_EDITS, ...CURSOR_EDITS].join('|')
   return {
@@ -47,20 +52,20 @@ export function hookSettings (command = hookCommand()) {
     UserPromptSubmit: [{ hooks: [run] }],
     PreToolUse: [{ matcher: edits, hooks: [run] }],
     PostToolUse: [{ matcher: edits, hooks: [run] }],
-    Stop: [{ hooks: [run] }],
+    ...(stop ? { Stop: [{ hooks: [run] }] } : {}),
     SessionEnd: [{ hooks: [run] }]
   }
 }
 
 /** Gemini CLI's hooks (its user settings.json): the same events under its names, timeouts in milliseconds. */
-export function geminiHookSettings (command = hookCommand('gemini')) {
+export function geminiHookSettings (command = hookCommand('gemini'), { stop = true } = {}) {
   const run = { type: 'command', command, timeout: 10000 }
   return {
     SessionStart: [{ hooks: [run] }],
     BeforeAgent: [{ hooks: [run] }],
     BeforeTool: [{ matcher: GEMINI_EDITS.join('|'), hooks: [run] }],
     AfterTool: [{ matcher: GEMINI_EDITS.join('|'), hooks: [run] }],
-    AfterAgent: [{ hooks: [run] }],
+    ...(stop ? { AfterAgent: [{ hooks: [run] }] } : {}),
     SessionEnd: [{ hooks: [run] }]
   }
 }

package/src/integrations.js

@@ -130,11 +130,13 @@ export function upsertHooks (file, ours) {
   const { json } = readJson(file)
   if (json === null) return 'skipped'
   const hooks = json.hooks && typeof json.hooks === 'object' && !Array.isArray(json.hooks) ? { ...json.hooks } : {}
+  // An event given no entries (`[]`) loses Quilt's: an event left with nothing goes.
   for (const [event, entries] of Object.entries(ours)) {
     const kept = (Array.isArray(hooks[event]) ? hooks[event] : [])
       .map((e) => (e && Array.isArray(e.hooks) ? { ...e, hooks: e.hooks.filter((h) => !isQuiltHook(h)) } : e))
       .filter((e) => e && (!Array.isArray(e.hooks) || e.hooks.length))
-    hooks[event] = [...kept, ...entries]
+    if (kept.length || entries.length) hooks[event] = [...kept, ...entries]
+    else delete hooks[event]
   }
   return upsertJsonKey(file, ['hooks'], hooks)
 }
@@ -168,7 +170,7 @@ export function knownTools ({ home = os.homedir(), platform = process.platform,
     { name: 'Cursor', dir: path.join(home, '.cursor'), file: path.join(home, '.cursor', 'mcp.json'), write: json(['mcpServers', 'quilt']) },
     { name: 'Windsurf', dir: path.join(home, '.codeium', 'windsurf'), file: path.join(home, '.codeium', 'windsurf', 'mcp_config.json'), write: json(['mcpServers', 'quilt']) },
     { name: 'Codex', dir: codexHome, file: path.join(codexHome, 'config.toml'), write: upsertCodexToml },
-    { name: 'Gemini CLI', dir: path.join(home, '.gemini'), file: path.join(home, '.gemini', 'settings.json'), write: (f, s, launch) => { const r = json(['mcpServers', 'quilt'])(f, s); return r === 'skipped' ? r : both(r, upsertHooks(f, geminiHookSettings(quiltShellCommand(['hook', 'gemini'], launch)))) } },
+    { name: 'Gemini CLI', dir: path.join(home, '.gemini'), file: path.join(home, '.gemini', 'settings.json'), write: (f, s, launch, { stop = false } = {}) => { const r = json(['mcpServers', 'quilt'])(f, s); return r === 'skipped' ? r : both(r, upsertHooks(f, { AfterAgent: [], ...geminiHookSettings(quiltShellCommand(['hook', 'gemini'], launch), { stop }) })) } },
     { name: 'GitHub Copilot CLI', dir: path.join(home, '.copilot'), file: path.join(home, '.copilot', 'mcp-config.json'), write: json(['mcpServers', 'quilt'], (s) => ({ type: 'local', ...s, tools: ['*'] })) },
     { name: 'Zed', dir: platform === 'win32' ? path.join(appData, 'Zed') : path.join(xdg, 'zed'), file: platform === 'win32' ? path.join(appData, 'Zed', 'settings.json') : path.join(xdg, 'zed', 'settings.json'), write: (f, s) => upsertZed(f, { source: 'custom', command: s.command, args: s.args, env: s.env || {} }) },
     { name: 'opencode', dir: path.join(xdg, 'opencode'), file: path.join(xdg, 'opencode', 'opencode.json'), write: json(['mcp', 'quilt'], (s) => ({ type: 'local', command: [s.command, ...s.args], enabled: true, ...(s.env ? { environment: s.env } : {}) })) },
@@ -186,14 +188,14 @@ export function knownTools ({ home = os.homedir(), platform = process.platform,
  * Returns [{ name, file, result }] for every tool found ('added' | 'updated' |
  * 'unchanged' | 'skipped' | 'busy' | 'failed', with `error` for failed).
  */
-export function registerEverywhere ({ launch = quiltLaunch(), ...where } = {}) {
+export function registerEverywhere ({ launch = quiltLaunch(), stop = false, ...where } = {}) {
   const server = mcpServer(launch)
   const out = []
   for (const t of knownTools(where)) {
     if (!fs.existsSync(t.dir)) continue
     try {
       if (t.busy && t.busy(t.file)) { out.push({ name: t.name, file: t.file, result: 'busy' }); continue }
-      out.push({ name: t.name, file: t.file, result: t.write(t.file, server, launch) })
+      out.push({ name: t.name, file: t.file, result: t.write(t.file, server, launch, { stop }) })
     } catch (err) {
       out.push({ name: t.name, file: t.file, result: 'failed', error: err.message })
     }

package/src/quilts/AGENTS.md

@@ -0,0 +1 @@
+The rules for this folder are in `seam/AGENTS.md`: seam is source control for more than Quilt.

package/src/quilts/CLAUDE.md

@@ -0,0 +1 @@
+@../../seam/AGENTS.md

package/src/quilts/tools.js

@@ -179,8 +179,6 @@ export async function runSeamTool (name, args, { client, found = null }) {
   }
 }
 
-/** Whether this process offers the source-control tools (QUILT_SOURCE, as the API's routes). */
-export const quiltToolsOn = (env = process.env) => /^(1|true|yes)$/i.test(env.QUILT_SOURCE || '')
 
 /**
  * Registers every tool on an MCP server. `client()` makes the quilt client for a call (it may

package/src/relay-ai-vm.js

@@ -27,7 +27,7 @@ const connected = (room, account) => [...room.conns.keys()].some((ws) => ws.pass
 
 /**
  * Looks at `room` for each cloud AI it knows: what is new for it. Returns the cloud AIs to wake
- * ([{ agent, room }]); `changed` says whether meta needs saving. Pure but for the room it reads.
+ * ([{ agent, room, why }], why: 'task' or 'message'); `changed` says whether meta needs saving. Pure but for the room it reads.
  */
 export function cloudAisToWake (room) {
   const out = []
@@ -46,7 +46,9 @@ export function cloudAisToWake (room) {
     entry.inbox = got.state
     changed = true
     if (seeded || !got.events.length) continue
-    if (!connected(room, entry.agent)) out.push({ agent: entry.agent.slice('agent:'.length), room: room.name })
+    // Why: a task for it, or a message (its person may have messages wait for its next wake).
+    const why = got.events.some((e) => e.kind === 'task') ? 'task' : 'message'
+    if (!connected(room, entry.agent)) out.push({ agent: entry.agent.slice('agent:'.length), room: room.name, why })
   }
   return { wake: out, changed }
 }
@@ -63,7 +65,7 @@ export function cloudAiOfPerson (room, ws) {
   if (!pass || pass.kind !== 'person') return null
   const entry = (room.meta.cloudAis || {})[`person:${pass.sub}`]
   if (!entry || !entry.agent || connected(room, entry.agent)) return null
-  return { agent: entry.agent.slice('agent:'.length), room: room.name }
+  return { agent: entry.agent.slice('agent:'.length), room: room.name, why: 'person' }
 }
 
 /**

package/src/runner.js

@@ -169,10 +169,11 @@ export async function runSession ({ dir, conn, name, tool, color = null, shareBy
   remember({ dir, room: conn.room, server: conn.server, name: session.name, tool, kind, workspace: savedWorkspace })
 
   // Every AI tool on this computer can reach Quilt (its MCP server, by absolute path), with nothing to set up.
-  registerOnStart((line) => session.log(line))
+  // An agent of its own also gets the hook as its AI finishes a turn; a person's AI sessions don't (hooks.js hookSettings).
+  registerOnStart((line) => session.log(line), { stop: kind === 'agent' })
   // Claude Code also applies Quilt's rules by itself through hooks (src/hooks.js), in this person's own
   // settings file; everyone's session writes its own, so the rule holds for everyone in the room.
-  try { if (installHooks(dir)) session.log(`🪝 added Quilt's Claude Code hooks to ${HOOKS_FILE}: files are checked before Claude edits them`) } catch {}
+  try { if (installHooks(dir, { stop: kind === 'agent' })) session.log(`🪝 added Quilt's Claude Code hooks to ${HOOKS_FILE}: files are checked before Claude edits them`) } catch {}
   releaseLeftoverHookClaims(session).then((n) => { if (n) session.log(`🔓 released ${n} claim(s) left by an earlier AI session`) }).catch(() => {})
 
   // Share this person's AI chat (Claude Code, Cursor) with the room.