heyquilt 0.3.107 → 0.3.109

package/src/session.js

@@ -2892,7 +2892,7 @@ export class Session extends EventEmitter {
     if (changed.length && this.followsRelay && this.branchLive()) {
       const atHead = await filesAt(this.root, head.sha, changed)
       const has = () => atHead && changed.every((rel) => this.sharedKey(rel) === (atHead.get(rel) ?? undefined))
-      if (atHead && !atHead.failed && (has() || await this.relayHasPull(head.sha, has))) old = atHead
+      if (atHead && !atHead.failed && (has() || await this.relayHasPull(head.sha, has))) old = this.pulledBases(changed, old, atHead)
     }
     if (old.failed) this.log(`⚠️ git could not read ${old.failed} file${old.failed === 1 ? '' : 's'} at the old commit; merged without a base, so where they differ the newer version stays`)
     // A file git made the person resolve (stash pop, rebase) holds their merge of the commits and the
@@ -2927,6 +2927,31 @@ export class Session extends EventEmitter {
     }
   }
 
+  /**
+   * The base of each pulled path once the relay is at the pulled commit (planSettle): the file at that commit,
+   * so the pull's change isn't shared again on top of the relay's. Not for a file the session doesn't have at
+   * that commit (the relay holds GitHub's change while someone holds the file) whose disk doesn't have the
+   * pull's change either (git moved the branch and left the file, as `git reset` does): measured from the
+   * commit, the disk would look like it took the pull's change away. That one is measured from the old commit.
+   */
+  pulledBases (rels, old, atHead) {
+    const out = new Map(atHead)
+    out.failed = 0
+    const text = (k) => typeof k === 'string' && !k.startsWith('bin:')
+    for (const rel of rels) {
+      const pulled = atHead.get(rel) ?? undefined
+      const was = old.get(rel) ?? undefined
+      if (pulled === was || this.sharedKey(rel) === pulled) continue
+      const disk = this.readDisk(rel)
+      const ours = disk && !disk.skip && !disk.tooLarge ? disk.key : null
+      if (ours === pulled) continue
+      // The disk has the pull's change when combining the pull into it changes nothing.
+      const hasPull = text(ours) && text(was) && text(pulled) && (() => { const m = merge3(was, ours, pulled); return !m.conflicts.length && m.text === ours })()
+      if (!hasPull) out.set(rel, old.get(rel))
+    }
+    return out
+  }
+
   onDisk (rel) {
     try { fs.lstatSync(path.join(this.root, ...rel.split('/'))); return true } catch { return false }
   }
@@ -5312,9 +5337,9 @@ export class Session extends EventEmitter {
       const r = cloudReader({ name: this.name, person: this.aiOf, states: this.conn && this.conn.awareness ? [...this.conn.awareness.getStates().values()] : [] })
       return { ...r, own: [...r.own, ...own] }
     }
-    // With no AI session of ours live, what is written to "<me>'s AI" waits here for the next one.
-    const aliases = this.kind !== 'agent' && !this.leadPersona() ? [aiName(this.name)] : []
-    return { name: this.name, aliases, asAi: this.kind !== 'agent', agent: this.kind === 'agent', own }
+    // Nothing written to "<me>'s AI" or handed to my AI comes here: that is the cloud AI's, and
+    // AI sessions on this computer take work when their person tells them to (from the board).
+    return { name: this.name, aliases: [], asAi: false, agent: this.kind === 'agent', own, ...(this.kind !== 'agent' ? { tasks: false } : {}) }
   }
 
   /**
@@ -5349,8 +5374,8 @@ export class Session extends EventEmitter {
   /** The names `via` (an AI session of ours, or this member when null) is known by in chat. */
   readerNames (via = null) {
     const p = this.persona(via)
-    if (p) return [p.name, ...p.aliases, aiName(this.name)]
-    return this.kind === 'agent' ? [this.name] : [this.name, aiName(this.name)]
+    if (p) return [p.name, ...p.aliases]
+    return [this.aiOf ? aiName(this.aiOf) : null, this.name].filter((n, i, a) => n && a.indexOf(n) === i)
   }
 
   /** Every message this member may read, the kept ones (chat-archive.js) before the room's, oldest first. */
@@ -5389,7 +5414,7 @@ export class Session extends EventEmitter {
     const r = (p ? p.inbox : this.inboxTracker).since(after)
     if (all) return { ...r, events: this.withContext(r.events, via), me: this.readerNames(via) }
     const msgs = this.chat.toArray().filter((m) => this.canSee(m))
-    const me = p ? [p.name, ...p.aliases, aiName(this.name)] : [this.name, aiName(this.name)]
+    const me = this.readerNames(via)
     // A commit request (e.commit: its id) waits until the request is done; a note that a commit was made is shown once.
     const open = (e) => typeof e.commit === 'string' ? this.commitRequests.get(e.commit)?.state === 'open' : (e.kind !== 'dm' && e.kind !== 'mention') || e.queue || e.commit || e.nudge ||
       (!this.settledIds.has(e.id) && !answered(msgs, me, e.by, e.ts))
@@ -5410,7 +5435,6 @@ export class Session extends EventEmitter {
   memberNames (me = this.name) {
     const names = new Set(this.peerNames())
     if (me !== this.name) names.add(this.name) // an AI session may write to its own person
-    for (const p of this.status().peers) if (p.persona && p.of && !p.mine) names.add(aiName(p.of)) // "Brandon's AI"
     for (const m of this.chat.toArray()) if (m && this.canSee(m)) { if (m.by) names.add(m.by); if (m.to) names.add(m.to) }
     names.delete(me)
     return [...names].filter((n) => typeof n === 'string' && n)
@@ -5583,13 +5607,21 @@ export class Session extends EventEmitter {
 
   /**
    * Commits everything the session changed since its last commit, from this folder, with `message`,
-   * and pushes (the GitHub chip's Commit and push): the files here that differ from HEAD and sync.
-   * It goes on record as a commit request made and done here, so nobody else is asked.
+   * and pushes: the files here that differ from HEAD and sync. `mine` (the git panel's Commit and
+   * push): only this person's own work (myUncommitted), boxed or not. It goes on record as a commit
+   * request made and done here, so nobody else is asked.
    */
-  async commitSessionWork (message) {
+  async commitSessionWork (message, { mine = false } = {}) {
     if (!this.canCommit()) throw new Error('this folder has no git (or no branch checked out), so it can’t commit: commit with git from a folder on this branch')
-    const dirty = await uncommitted(this.root)
-    const files = dirty ? [...dirty.keys()].filter((rel) => this.syncable(rel)).slice(0, MAX_REQUEST_FILES) : []
+    let files
+    if (mine) {
+      const own = await this.myUncommitted()
+      files = own ? own.files.map((f) => f.path).filter((rel) => this.syncable(rel)).slice(0, MAX_REQUEST_FILES) : []
+      if (!files.length) throw new Error('nothing of yours to commit: your work here is all in git')
+    } else {
+      const dirty = await uncommitted(this.root)
+      files = dirty ? [...dirty.keys()].filter((rel) => this.syncable(rel)).slice(0, MAX_REQUEST_FILES) : []
+    }
     if (!files.length) throw new Error('nothing to commit: this folder matches its last commit')
     const r = this.requestCommit(message, { files, by: this.name, quiet: true })
     return this.commitRequest(r.id)
@@ -5696,6 +5728,30 @@ export class Session extends EventEmitter {
     return { branch: this.git.branch, groups: uncommittedByPerson(editors), requests }
   }
 
+  /** Whether a name the history gives is this person's: theirs, one of their AI sessions', or their cloud AI's. */
+  ownName (name) {
+    if (this.isMine(name)) return true
+    if (this.aiOf || !this.conn || !this.conn.awareness) return false
+    for (const [id, st] of this.conn.awareness.getStates()) if (id !== this.doc.clientID && isCloudAi(st) && st.aiOf === this.name && st.name === name) return true
+    return false
+  }
+
+  /**
+   * This person's own work not committed in this folder (theirs and their AIs'; nobody else's), for
+   * the app's git panel: { branch, files: [{ path, boxed }] }, `boxed` when it is in their box (in
+   * this folder only so far), else everyone has it. Null without git.
+   */
+  async myUncommitted () {
+    const work = await this.uncommittedWork()
+    if (!work) return null
+    const dirty = new Set(work.groups.flatMap((g) => g.files))
+    const paths = new Set(work.groups.filter((g) => g.by && this.ownName(g.by)).flatMap((g) => g.files))
+    const boxed = new Set()
+    for (const c of this.claims.values()) if (c && c.box && this.ownClaim(c) && dirty.has(c.pattern)) boxed.add(c.pattern)
+    for (const rel of boxed) paths.add(rel)
+    return { branch: work.branch, files: [...paths].sort().map((p) => ({ path: p, boxed: boxed.has(p) })) }
+  }
+
   /** Looks at the open requests again soon (one came in, or one was committed). */
   reviewCommitsSoon (ms = 5000) {
     if (this.stopped || !this.canCommit()) return
@@ -5934,10 +5990,13 @@ export class Session extends EventEmitter {
     return { changed: plan.changes.map((c) => c.path), manual: plan.manual }
   }
 
-  /** Whether an inbox event of this member's is for their AI: a task given to it, or a message to or mentioning "<me>'s AI". */
+  /**
+   * Whether an inbox event is for this person's AI: a task given to it, or a message to or
+   * mentioning "<person>'s AI". Only a cloud AI is that (cloud-ai.js); on a computer, nothing is.
+   */
   forMyAi (e) {
-    // A person's cloud AI works for its person's AI, and for itself by name.
-    const ai = aiName(this.aiOf || this.name)
+    if (!this.aiOf) return false
+    const ai = aiName(this.aiOf)
     if (e.kind === 'task') return !!e.task && ((e.task.assignee === (this.aiOf || this.name) && !!e.task.forAi) || (!!this.aiOf && e.task.assignee === this.name))
     const m = this.chat.toArray().find((x) => x && x.id === e.id)
     if (!m) return false
@@ -5961,16 +6020,16 @@ export class Session extends EventEmitter {
   /** Whether a name is this member's or one of its AI sessions' (now or before a rename). */
   isMine (name) {
     if (!name) return false
-    if (name === this.name || name === aiName(this.name)) return true
-    // A person's cloud AI is their AI: what is written to "<person>'s AI" is its to read.
+    if (name === this.name) return true
+    // A person's cloud AI is "<person>'s AI": that name is its own, never its person's computer's.
     if (this.aiOf && name === aiName(this.aiOf)) return true
     for (const p of this.personas.values()) if (p.name === name || p.aliases.includes(name)) return true
     return false
   }
 
-  /** Every name this member answers to: its own, "<name>'s AI", and its AI sessions' (now and before a rename). */
+  /** Every name this member answers to: its own (a cloud AI's is "<person>'s AI"), and its AI sessions' (now and before a rename). */
   ownNames () {
-    return [this.name, aiName(this.name), ...(this.aiOf ? [aiName(this.aiOf)] : []), ...[...this.personas.values()].flatMap((p) => [p.name, ...p.aliases])]
+    return [this.name, ...(this.aiOf ? [aiName(this.aiOf)] : []), ...[...this.personas.values()].flatMap((p) => [p.name, ...p.aliases])]
   }
 
   /** Whether a claim is this member's or one of its AI sessions': files on this disk are ours to write. */
@@ -5983,14 +6042,13 @@ export class Session extends EventEmitter {
   }
 
   /**
-   * How an AI session reads the inbox. What is written to "<person>'s AI" goes to one session
-   * only, the one of ours active most recently, so a question is answered once.
+   * How an AI session reads the inbox: by its own name only. What is written to "<person>'s AI"
+   * is the cloud AI's, and work for the person's AI waits on the board until they ask for it.
    */
   personaReader (p) {
-    const aliases = p === this.leadPersona() ? [...p.aliases, aiName(this.name)] : p.aliases
     // Its sibling sessions here don't wake it: they work for the same person.
     const own = [...this.personas.values()].filter((q) => q !== p).flatMap((q) => [q.name, ...q.aliases])
-    return { name: p.name, aliases, asAi: false, agent: true, of: this.name, own }
+    return { name: p.name, aliases: p.aliases, asAi: false, agent: true, own }
   }
 
   /** The AI session of ours that answers for "<person>'s AI": the live one heard from last, or null. */
@@ -6110,7 +6168,7 @@ export class Session extends EventEmitter {
     const reply = replyFor(visible, { names: this.ownNames(), to, re: re ? String(re).trim() : '' })
     if (reply.error) throw new Error(reply.error)
     to = reply.to
-    if (to === by || (to && via && this.persona(via) && to === aiName(this.name))) throw new Error('that is you')
+    if (to === by) throw new Error('that is you')
     const names = agent ? this.memberNames(by) : []
     const targets = agent ? addressees(text, to, names) : []
     if (agent && !file) {
@@ -6135,7 +6193,7 @@ export class Session extends EventEmitter {
     if (via) this.aiSent.push({ via: String(via), targets, text, ts: msg.ts })
     if (agent && text) this.noteActivity(`${to ? `To ${to}` : 'In chat'}: ${text}`, { via, kind: 'reply' })
     this.scheduleStatusWrite()
-    const online = !to || this.peerNames().includes(to) || this.status().peers.some((p) => p.persona && p.of && aiName(p.of) === to)
+    const online = !to || this.peerNames().includes(to)
     const away = !online && (this.members || []).some((m) => m.away && m.name === to)
     return { ...this.describeMessage(msg), recipientOnline: online, ...(away ? { recipientAway: true } : {}) }
   }
@@ -6303,7 +6361,9 @@ export class Session extends EventEmitter {
 
   /** Whether a message is meant for me: a well-formed one that is public, mine, or addressed to me. */
   canSee (msg) {
-    return validMessage(msg) && (!msg.to || this.isMine(msg.to) || this.isMine(msg.by))
+    // A person also sees what is written to and by their cloud AI ("<me>'s AI"): it is theirs.
+    const mineOrMyAi = (n) => this.isMine(n) || (this.kind !== 'agent' && n === aiName(this.name))
+    return validMessage(msg) && (!msg.to || mineOrMyAi(msg.to) || mineOrMyAi(msg.by))
   }
 
   peerNames () {

package/src/setup.js

@@ -39,10 +39,10 @@ ${TASK_WORKFLOW_MD}
   AI sessions, named after your work: "<their first name> · <label>", from your git
   branch or the first thing you say you're 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": write to another person's AI
-  by that name ("@Daniel's AI"), 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: their own AI tool on their own cloud VM).
+  see each AI session by its own name. "<person>'s AI" ("@Daniel's AI") is only that
+  person's cloud AI, when they connected one (their own AI tool on their own cloud
+  machine). Nothing written or handed to "<person>'s AI" comes to you; when your person
+  asks you to work on tasks, take them from the board (\`quilt_tasks\`).
 - Claims follow edits, whatever tool you are: the moment you change a file nobody
   holds, Quilt claims it for you, and lets go when you finish (your AI goes idle, or
   the file has been quiet for a few minutes). Claim ahead only for a larger change

package/src/ui/agent-guide.js

@@ -73,7 +73,7 @@ export function agentGuide ({ apiUrl = 'https://api.heyquilt.com', via = 'both'
     '- `quilt_tasks` lists the board (To do, In progress, QA, Done) with ids; open tasks assigned to you come first.',
     '- `quilt_task` reads one task in full with its comments; `quilt_comment_task` leaves a work note, a handoff or the reason for an assignment on it, instead of in the chat.',
     '- Keep notes on tickets brief, the same as chat: comments, qaNotes and verified say in a few short sentences what changed, why, and how you checked it. Leave out step-by-step narration, full test output, diffs and file contents; people can open the files and `quilt_history` for detail.',
-    `- Add: ${call('quilt_add_task', { title: 'a few words', assignee: '<name> or me', files: ['src/app.js'] })}. Assign: ${call('quilt_assign_task', { id: '<task id>', assignee: '<name>', to_ai: true })}. to_ai: true gives it to that person's AI instead of the person; an agent is assigned by its own name, without to_ai.`,
+    `- Add: ${call('quilt_add_task', { title: 'a few words', assignee: '<name> or me', files: ['src/app.js'] })}. Assign: ${call('quilt_assign_task', { id: '<task id>', assignee: '<name>', to_ai: true })}. to_ai: true gives it to that person's AI (their cloud AI, when they connected one) instead of the person; an agent or an AI session is assigned by its own name, without to_ai.`,
     `- Move: ${call('quilt_move_task', { id: '<task id>', column: 'doing' })} when you start (you get a briefing: its files, recent changes, claims, the project's checks); "qa" when done and tested, with qaNotes (what changed, how you checked it); "done" after QA, with verified (what you ran and what you saw). A move without those is refused.`,
     '- A task handed to you wakes you like a direct message. Take it with quilt_move_task, or say in chat why not.',
     '- If you change files for something not on the board, Quilt adds an In progress task for it: use that one rather than adding another, and move it on when you finish. `quilt_archive_task` takes a task off the board but keeps it (archived false brings it back); `quilt_delete_task` removes it for good.',

package/src/ui/app.css

@@ -2170,16 +2170,6 @@ label.radio, .field label.radio { display: flex; align-items: center; gap: 8px;
 label.radio input { margin: 0; }
 label.radio:has(input:disabled) { cursor: default; opacity: .75; }
 
-/* When work comes to your AI (Settings → Your AI): today's usage and the latest runs. */
-#auto-usage { border-top: 1px solid var(--border); margin-top: 6px; padding-top: 6px; }
-#auto-usage:empty { display: none; }
-.auto-usage-head { font-size: 12px; font-weight: 600; text-transform: uppercase; letter-spacing: .04em; color: var(--muted); margin: 10px 0 2px; }
-.auto-runs { display: flex; flex-direction: column; }
-.auto-run { display: flex; align-items: center; gap: 12px; padding: 8px 0; border-bottom: 1px solid var(--border); }
-.auto-run:last-child { border-bottom: 0; }
-.auto-run .nm { display: flex; flex-direction: column; min-width: 0; flex: 1; }
-.auto-run .nm b { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-
 /* One set of AI rules (session ⋯ menu): what gathering into AGENTS.md changes, file by file. */
 .gather-rules { width: min(760px, 100%); max-height: min(86vh, 900px); padding: 0; display: flex; flex-direction: column; overflow: hidden; }
 .gr-body { min-height: 0; overflow-y: auto; padding: 16px 24px 20px; }
@@ -2199,6 +2189,22 @@ label.radio:has(input:disabled) { cursor: default; opacity: .75; }
 .branch-menu .br-compact .br-sync { flex: none; margin: 0; height: 24px; padding: 0 8px; gap: 4px; font-size: 12px; }
 .branch-menu .br-compact .br-sync svg { width: 12px; height: 12px; color: inherit; }
 .cp-line { display: flex; align-items: center; gap: 8px; margin: 0 0 8px; font-size: 12.5px; min-width: 0; }
+/* Your work not committed (session.js mineHtml): two lines, boxed and shared, each opening to its files. */
+.mw-head { display: flex; align-items: baseline; justify-content: space-between; }
+.mw-head h4 { margin-top: 0; }
+.mw-none { margin: 0 2px 4px; font-size: 12.5px; color: var(--muted); }
+details.mw { margin: 0 0 4px; }
+details.mw summary { list-style: none; cursor: pointer; display: flex; align-items: center; gap: 8px; min-height: 30px; padding: 0 4px; font-size: 13px; border-radius: 4px; }
+details.mw summary::-webkit-details-marker { display: none; }
+details.mw summary:hover { background: var(--panel-2); }
+details.mw summary .hint { font-size: 12.5px; }
+.mw-ico { width: 14px; height: 14px; display: grid; place-items: center; flex: none; }
+.mw-ico svg { width: 14px; height: 14px; color: var(--box, var(--warn)); }
+.mw-dot { width: 8px; height: 8px; border-radius: 50%; background: var(--edit); }
+details.mw ul { list-style: none; margin: 0 0 6px; padding: 0 0 0 26px; }
+details.mw li { min-height: 26px; display: flex; align-items: center; min-width: 0; }
+details.mw li code { font-size: 12px; color: var(--muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; min-width: 0; }
+details.mw + .cp-commit, .mw-head + .cp-commit { margin-top: 8px; }
 .cp-line:last-child { margin-bottom: 0; }
 .cp-line > span:not(.sd) { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .cp-line .sd { width: 7px; height: 7px; border-radius: 50%; background: var(--faint); flex: none; }

package/src/ui/chat.js

@@ -136,33 +136,19 @@ export function relayPrompts (text, { owner = false } = {}) {
   return RELAY_QUESTIONS.filter((q) => owner || !q.owner)
 }
 
-// One name for all of a person's AI sessions. People see "Daniel's AI" rather than each chat
-// ("Daniel · file-queue", "Daniel · Claude Code 3"), and can write to it: the session of theirs
-// active most recently answers (src/session.js leadPersona).
+// "<person>'s AI" is a person's cloud AI (src/cloud-ai.js), and only that: their AI sessions on
+// computers are shown by their own names ("Daniel · file-queue", "Daniel · Claude Code 3").
 export const AI_SUFFIX = '\'s AI'
 
-/** "Daniel's AI": every AI session working through Daniel's app, as one name. */
+/** "Daniel's AI": Daniel's cloud AI's name. */
 export const aiName = (person) => `${String(person || '').trim()}${AI_SUFFIX}`
 
 /**
- * Peers as people see them: the AI sessions of each person (persona: true, of: person) folded
- * into one "<person>'s AI" entry listing them under `sessions`. Order is kept (first seen wins).
+ * Peers as people see them: each AI session as itself (by its own name, kind agent), with whose
+ * it is (`aiOf`). Nothing is folded into one "<person>'s AI": that name is only a cloud AI's.
  */
 export function foldPersonas (peers) {
-  const out = []
-  const groups = new Map()
-  for (const p of peers || []) {
-    if (!p || !p.persona || !p.of) { out.push(p); continue }
-    let g = groups.get(p.of)
-    if (!g) {
-      g = { name: aiName(p.of), kind: 'agent', aiOf: p.of, ...(p.mine ? { mine: true } : {}), tool: '', agents: [], focus: '', editing: [], sessions: [] }
-      groups.set(p.of, g)
-      out.push(g)
-    }
-    g.sessions.push({ name: p.name, tool: p.tool || '', focus: p.focus || '' })
-    if (p.tool && !g.agents.includes(p.tool)) g.agents.push(p.tool)
-  }
-  return out
+  return (peers || []).map((p) => (p && p.persona && p.of ? { ...p, kind: 'agent', aiOf: p.of } : p))
 }
 
 const PERSONA_SEP = ' · ' // src/persona.js: "Daniel · file-queue"
@@ -195,8 +181,8 @@ export function aiOwners ({ peers = [], messages = [], people = [], names = [] }
   return owners
 }
 
-/** A name as people see it: one of someone's AI sessions is "<person>'s AI". */
-export const shownName = (name, owners) => owners && owners.has(name) ? aiName(owners.get(name)) : name
+/** A name as people see it: its own (an AI session is never shown as "<person>'s AI"). */
+export const shownName = (name) => name
 
 /**
  * True when a message is one of a person's AI sessions writing to another of their own (by

package/src/ui/cloud-ai.js

@@ -20,7 +20,7 @@ export function cloudAiCardHtml () {
 const pill = (s) => `<span class="pill cai-pill ${s.tone}"><span class="dot"></span>${esc(s.label)}</span>`
 
 function connectHtml (ui) {
-  return `<div class="sec-intro"><h2>${TITLE}</h2><p>Your own AI tool, signed in with your own account, on a machine of yours that is always there. It answers for your AI when none of your AI sessions is open.</p></div>
+  return `<div class="sec-intro"><h2>${TITLE}</h2><p>Your own AI tool, signed in with your own account, on a machine of yours that is always there. It becomes "your AI": what anyone writes or hands to your AI goes to it.</p></div>
   <div class="sec-body cai-body">
     <div class="cai-tools">${CLOUD_TOOLS.map((t, i) => `<div class="cai-tool">
       ${toolLogo(t.tool, { className: 'cai-logo' })}
@@ -76,16 +76,15 @@ function signInHtml (vm, ui) {
 function readyHtml (vm, ui) {
   const st = cloudStatus(vm)
   const u = cloudUsage(vm)
-  const me = state.profile && state.profile.name ? state.profile.name.split(/\s+/)[0] : 'your'
   const online = vm.state === 'running' ? true : vm.state === 'suspended' ? 'away' : false
   const sleeping = ['suspended', 'stopped', 'failed'].includes(vm.state)
   const sessions = (vm.sessions || []).length
     ? `<div class="cai-sessions">${vm.sessions.map((s) => `<div class="cai-sess"><span class="grow"><b>${esc(s.name || s.room)}</b></span><span class="hint">joined</span></div>`).join('')}</div>`
     : '<p class="hint">In no session yet. It joins the sessions you join, and stays when you leave for the day.</p>'
-  return `<div class="sec-intro"><h2>${TITLE}</h2><p>It answers for your AI when none of your AI sessions is open: tasks, @mentions and messages, while your computer is closed.</p></div>
+  return `<div class="sec-intro"><h2>${TITLE}</h2><p>This is your AI: tasks, @mentions and messages for it come here, even while your computer is closed. Your AI sessions on your computer keep their own names.</p></div>
   <div class="sec-body cai-body">
     <div class="cai-who">${avatar(vm.name || 'AI', state.profile && state.profile.color, online)}
-      <div class="grow"><b>${esc(vm.name || 'Cloud AI')}</b><span class="hint">${esc(vm.tool)} on your cloud machine · one of ${esc(me === 'your' ? 'your' : `${me}'s`)} AI</span></div>
+      <div class="grow"><b>${esc(vm.name || 'Cloud AI')}</b><span class="hint">${esc(vm.tool)} on your cloud machine</span></div>
       ${pill(st)}
       ${sleeping ? `<button class="btn sm" type="button" data-cloud-wake ${ui.busy === 'wake' ? 'disabled' : ''}>${vm.state === 'suspended' ? 'Wake now' : 'Start it again'}</button>` : ''}
     </div>
@@ -98,7 +97,7 @@ function readyHtml (vm, ui) {
       <div><b>${u.pct === null ? 'No cap' : `${u.pct}%`}</b><span>${u.pct === null ? 'set a daily cap below' : `of ${esc(u.cap)} daily cap`}</span></div>
     </div>
     ${u.pct === null ? '' : `<div class="cai-meter${u.over ? ' over' : ''}" role="meter" aria-valuemin="0" aria-valuemax="100" aria-valuenow="${u.pct}" aria-label="Today's use of the daily cap"><i style="width:${u.pct}%"></i></div>`}
-    ${u.over ? '<p class="hint warn">The daily cap is reached: work waits for your chat until tomorrow.</p>' : ''}
+    ${u.over ? '<p class="hint warn">The daily cap is reached: work for your AI waits on the board until tomorrow.</p>' : ''}
     <hr class="cai-sep">
     <form class="cai-form" id="cloud-settings-form" autocomplete="off">
       <div class="cai-two">

package/src/ui/home.js

@@ -787,76 +787,12 @@ function workspacesSettingsHtml () {
   </section>`
 }
 
-const AUTO_CHOICES = [['chat', 'Leave it for my chat'], ['open', 'Open it in my tool'], ['auto', 'Work on its own']]
-
-/** "When work comes to my AI" (src/autowork.js): leave it, open it, or let the AI work on its own. */
-function autoSettingsHtml (p) {
-  const a = p.auto || { mode: 'chat', supported: false, models: [], model: '', changeFiles: false, limitsFiles: true, cap: 0, tool: p.tool }
-  const tool = esc(a.tool || p.tool || 'your AI tool')
-  return `<form class="card settings-sec" id="auto-sec" autocomplete="off">
-    <div class="sec-intro"><h2>When work comes to your AI</h2><p>A task given to your AI, or a merge sent to it, while none of your AI sessions is open.</p></div>
-    <div class="sec-body">
-      <div class="field">
-        <label for="s-autowork">Do this</label>
-        <select class="input" id="s-autowork" name="autoWork">${AUTO_CHOICES.map(([v, l]) => {
-          const off = v === 'auto' && !a.supported && a.mode !== 'auto'
-          return `<option value="${v}" ${a.mode === v ? 'selected' : ''} ${off ? 'disabled' : ''}>${l}${off ? ` (not available for ${tool})` : ''}</option>`
-        }).join('')}</select>
-        <span class="hint" id="s-autowork-hint">${autoHint(a.mode, tool)}</span>
-      </div>
-      <div class="auto-only" ${a.mode === 'auto' ? '' : 'hidden'}>
-        ${a.supported ? '' : `<p class="error">${tool} can't work on its own. Pick Claude Code, Cursor, Codex or GitHub Copilot in your profile, or choose another option.</p>`}
-        <div class="field">
-          <label for="s-automodel">Model</label>
-          <input class="input" id="s-automodel" name="autoModel" list="s-automodels" value="${esc(a.model || '')}" placeholder="${esc(a.models[0] || '')}">
-          <datalist id="s-automodels">${a.models.map((m) => `<option value="${esc(m)}">`).join('')}</datalist>
-          <span class="hint">${a.models.length ? `Suggested: ${a.models.map(esc).join(', ')}. ${esc(a.models[0])} is the default; type any model ${tool} knows.` : 'The model your tool uses by default.'}</span>
-        </div>
-        ${toggle('autoFiles', a.changeFiles, 'Let it change files', a.limitsFiles ? 'Off: it reads, plans, comments and asks, and leaves changes to you. File claims apply either way.' : `${tool} can change files either way; this also lets it run commands. File claims apply either way.`)}
-        <div class="field">
-          <label for="s-autocap">Daily limit (tokens)</label>
-          <input class="input" id="s-autocap" name="autoCap" type="number" min="0" step="1000" value="${a.cap || ''}" placeholder="No limit">
-          <span class="hint">Past it, work waits for your chat until tomorrow, and you're told once.</span>
-        </div>
-      </div>
-      <div class="sec-actions"><span><span class="hint auto-only" ${a.mode === 'auto' ? '' : 'hidden'}>Runs on this computer, with your own ${tool} account, while Quilt is open. It asks questions in Quilt chat; a reply carries the same chat on.</span></span><button class="btn primary" type="submit">Save</button></div>
-      <div id="auto-usage"></div>
-    </div>
-  </form>`
-}
-
-function autoHint (mode, tool) {
-  if (mode === 'auto') return `${tool} starts on the work by itself, in the session's folder. You see what it does in the feed and its questions in chat.`
-  if (mode === 'open') return `${tool} opens on the work in the session's folder, for you to drive.`
-  return 'Nothing opens: your AI picks it up from its inbox the next time you work with it.'
-}
-
-/** Today's runs and tokens, and the latest runs with a way to carry each chat on. */
-function autoUsageHtml (u) {
-  const tools = Object.entries(u.today || {})
-  const n = (x) => Number(x || 0).toLocaleString()
-  const today = tools.length
-    ? tools.map(([t, v]) => `<div class="kv"><span>${esc(t)}</span><b>${n(v.input + v.output)} tokens</b><span class="hint">${v.runs} run${v.runs === 1 ? '' : 's'} today${v.costUsd ? ` · $${v.costUsd.toFixed(2)}` : ''}</span></div>`).join('')
-    : '<p class="hint">No runs today.</p>'
-  const runs = (u.runs || []).slice(0, 8).map((r) => `<div class="auto-run">
-      <span class="nm"><b>${esc(r.title || r.kind)}</b><span class="hint">${esc(r.tool)} · ${r.reported ? `${n(r.input + r.output)} tokens` : 'tokens not reported'} · ${r.outcome === 'ok' ? 'finished' : 'failed'} · ${ago(r.ts)}</span></span>
-      ${r.chatId ? `<button class="btn sm" type="button" data-take-over="${esc(r.run)}">Open chat</button>` : ''}
-    </div>`).join('')
-  return `<h3 class="auto-usage-head">Today</h3>${today}${runs ? `<h3 class="auto-usage-head">Latest runs</h3><div class="auto-runs">${runs}</div>` : ''}`
-}
-
-async function loadAutoUsage (root) {
-  const box = $('#auto-usage', root)
-  if (!box) return
-  try { box.innerHTML = autoUsageHtml(await api('GET', '/api/autowork')) } catch (err) { box.innerHTML = `<p class="error">${esc(err.message)}</p>` }
-}
-
 function settingsHtml ({ head = true } = {}) {
   const p = state.profile
   const a = state.account || { name: p.name, email: '' }
   const theme = p.theme || document.documentElement.dataset.theme || 'dark'
   const tab = settingsTab()
-  const show = (id) => ({ account: ['account', 'about', 'computer'], you: ['profile', 'appearance', 'sounds'], sessions: ['sessions'], agents: ['your-ai', 'auto', 'cloud-ai', 'agents', 'agents-git'], workspaces: ['workspaces'] })[tab].includes(id)
+  const show = (id) => ({ account: ['account', 'about', 'computer'], you: ['profile', 'appearance', 'sounds'], sessions: ['sessions'], agents: ['your-ai', 'cloud-ai', 'agents', 'agents-git'], workspaces: ['workspaces'] })[tab].includes(id)
   return `
   ${head ? `<header class="page-head">
     <h1>Settings</h1>
@@ -886,7 +822,6 @@ function settingsHtml ({ head = true } = {}) {
     </div>
   </form>` : ''}
 
-  ${show('auto') ? autoSettingsHtml(p) : ''}
 
   ${show('cloud-ai') ? cloudAiCardHtml() : ''}
 
@@ -1212,27 +1147,6 @@ function bindSettings (root, refresh) {
   const ai = $('#your-ai-sec', root)
   if (ai) saveForm(ai, (f) => ({ shareAgent: !!f.get('shareAgent'), summarize: !!f.get('summarize'), aiTasks: f.get('aiTasks') }))
 
-  const auto = $('#auto-sec', root)
-  if (auto) {
-    saveForm(auto, (f) => ({ autoWork: f.get('autoWork'), ...(f.get('autoWork') === 'auto' ? { autoModel: f.get('autoModel'), autoFiles: !!f.get('autoFiles'), autoCap: f.get('autoCap') } : {}) }))
-    const sel = $('#s-autowork', auto)
-    sel.onchange = () => {
-      for (const el of auto.querySelectorAll('.auto-only')) el.hidden = sel.value !== 'auto'
-      $('#s-autowork-hint', auto).textContent = autoHint(sel.value, state.profile.auto?.tool || state.profile.tool)
-    }
-    auto.addEventListener('click', async (e) => {
-      const b = e.target.closest('[data-take-over]')
-      if (!b) return
-      b.disabled = true
-      try {
-        const r = await api('POST', '/api/autowork/take-over', { run: b.dataset.takeOver })
-        toast(r.opened ? 'Opened the chat in your AI tool' : r.copied ? `Copied: ${r.command}. Paste it in a terminal.` : r.command)
-      } catch (err) { toast(err.message) }
-      b.disabled = false
-    })
-    loadAutoUsage(root)
-  }
-
   const cloud = $('#cloud-ai-sec', root)
   if (cloud) bindCloudAi(cloud)
 

package/src/ui/loom-model.js

@@ -6,7 +6,6 @@
 // thin strips (and past a few strips, into one "crowd" column) where each thing
 // they did is a knot in the same rows. Pure, so it can be tested without a browser.
 import { conversations } from './feed-convs.js'
-import { aiName } from './chat.js'
 
 export const GAP_MS = 20 * 60 * 1000 // a pause this long between two things gets a "later" divider
 export const TURN_GAP_MS = 10 * 60 * 1000 // a conversation quiet this long starts a new turn without a prompt
@@ -270,13 +269,13 @@ function dayOf (ts) {
 }
 
 /**
- * One lane per person's AI, as chat shows it: every AI session of a person ("Daniel · Claude
- * Code", "Daniel · Claude Code 2", ones gone since) becomes "Daniel's AI". `owners`: AI session
- * name -> its person (chat.js aiOwners). Returns the buildLoom inputs with those names folded,
- * and `personOf`: lane name -> the person whose AI chat it opens.
+ * The Loom's lanes, as chat shows them: each AI session is a lane of its own ("Daniel · Claude
+ * Code", "Daniel · file-queue"); none is folded into "<person>'s AI". `owners`: AI session name
+ * -> its person (chat.js aiOwners). Returns the buildLoom inputs and `personOf`: lane name -> the
+ * person whose AI it is.
  */
 export function foldAiLanes ({ people = [], owners = new Map(), feeds = new Map(), messages = [], tasks = [], claims = [] } = {}) {
-  const lane = (name) => owners.has(name) ? aiName(owners.get(name)) : name
+  const lane = (name) => name
   const personOf = new Map()
   const out = []
   const groups = new Map()
@@ -297,14 +296,14 @@ export function foldAiLanes ({ people = [], owners = new Map(), feeds = new Map(
     personOf.set(name, owners.get(p.name))
     out.push(folded)
   }
-  // An AI session that is gone still has its chat and notes: they go to its person's AI lane.
-  for (const person of new Set(owners.values())) {
-    const name = aiName(person)
-    if (groups.has(name)) continue
+  // An AI session that is gone still has its chat and notes: it keeps a lane of its own for them.
+  for (const [name, person] of owners) {
+    if (groups.has(name) || out.some((p) => p && p.name === name)) continue
     groups.set(name, true)
     personOf.set(name, person)
     out.push({ name, kind: 'agent', tool: '', online: false, optional: true, agent: null })
   }
+
   const folded = new Map()
   for (const [name, list] of feeds) {
     const key = lane(name)

package/src/ui/rail-model.js

@@ -12,15 +12,16 @@ const claimFolder = (pattern) => String(pattern).replace(/\/\*\*$/, '').replace(
 /**
  * Everything the rail and its lock list show. `claims`: the session's ({ pattern, by, ts, note,
  * active, activeAt, queue }); `me`: your name;
- * `owners`: AI session name -> its person (chat.js aiOwners), so a person's AI sessions are one
- * holder, "<person>'s AI"; `aiName`: person -> that name; `files`: the session's paths (to count a
+ * `owners`: AI session name -> its person (chat.js aiOwners); each AI session holds its claims
+ * under its own name; `aiName` is unused (kept for callers); `files`: the session's paths (to count a
  * folder's); `focusOf`: name -> what they
  * said they're doing (a lock's why when it has no note); `kindOf`: name -> 'agent' for an AI agent.
  * Returns { locks, holders, waiting, mine }, locks oldest first.
  */
 export function railModel ({ claims = [], me = '', owners = new Map(), aiName = (p) => `${p}'s AI`, files = [], focusOf = () => '', kindOf = () => '', now = Date.now(), idleMs = CLAIM_IDLE_MS } = {}) {
   const fileSet = new Set(files)
-  const holderOf = (by) => owners.has(by) ? aiName(owners.get(by)) : by
+  // Each AI session holds its claims under its own name.
+  const holderOf = (by) => by
   const locks = (claims || []).filter((c) => c && c.pattern && c.by).map((c) => {
     const bare = claimFolder(c.pattern)
     // "src/auth", "src/auth/" and "src/auth/**" all claim the folder (tree.js claimFolder).