heyquilt 0.3.108 → 0.3.109

package/README.md

@@ -378,16 +378,14 @@ the way the agent listens for it, and mentions are marked in every message.
 
 ### Your AI on its own cloud machine
 
-Quilt runs a person's AI only when they turn "Work on its own" on in Settings → Your AI, and
-then only their own AI tool with their own account: on their own computer, or on their own
-cloud VM they connected. **Connect Claude**, **Connect Codex** or **Connect Cursor** there
-starts a small machine for that person alone (never the relay) and signs the tool in with its
-own login: the app shows the link and code, and Quilt never asks for, keeps or passes on the
-tool's token, or pays for its use. From then on it is one of the person's AI sessions,
-"Daniel · cloud" under "Daniel's AI": it joins the sessions they join and, while none of
-their AI sessions on a computer is live, takes tasks for their AI and answers what is written
-to it, with its own model, instructions and daily cap. It sleeps when idle and wakes when it
-is needed. Disconnect deletes the machine and its disk.
+Quilt runs a person's AI only on their own cloud machine they connected, with their own AI
+tool and their own account. **Connect Claude**, **Connect Codex** or **Connect Cursor** in
+Settings → Your AI starts a small machine for that person alone (never the relay) and signs the
+tool in with its own login: the app shows the link and code, and Quilt never asks for, keeps or
+passes on the tool's token, or pays for its use. From then on it is "Daniel's AI", the only
+member by that name: it joins the sessions they join, takes tasks for their AI and answers what
+is written to it, with its own model, instructions and daily cap. It sleeps when idle and wakes
+when it is needed. Disconnect deletes the machine and its disk.
 
 ### Webhooks: an agent sets up its own push
 

package/RELEASES.md

@@ -11,6 +11,17 @@ 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.109 — 2026-10-20
+
+"Your AI" is your cloud AI, and only that.
+
+- **Each AI session is shown as itself.** The member list, chat, file locks and the Loom show each of your AI sessions by its own name ("Daniel · file-queue"), instead of folding them all into "Daniel's AI".
+- **"Daniel's AI" is your cloud AI.** Connected, your cloud AI is named "Daniel's AI": what anyone writes or hands to your AI goes to it, whether or not you have AI sessions open. Without one, nobody is "Daniel's AI".
+- **Nothing is pushed to the AI sessions on your computer.** Messages, mentions and tasks for your AI no longer land in whichever session you used last, and your computer never starts a run on its own: work for your AI waits on the board until you ask your AI for it. The "When work comes to your AI" settings are gone with it.
+- **Your cloud AI talks caveman.** It answers in short, plain sentences (the caveman skill, for Claude Code, Codex and Cursor), so its notes cost fewer tokens. Code, commands, paths and commit messages stay exact.
+- **Workspaces are off for now.** Home lists your sessions again, and workspaces, workspace invites, the Agents page and your AI's workspace library tools (and `quilt workspace`) are gone from the app. Nothing in them is deleted; they come back if they turn out to be missed.
+- **The git panel shows only your work not committed.** It used to count every file anyone in the session had changed (14, say), with nothing about whose they were. Now it lists just yours and your AIs', in two lines: boxed (only in your folder so far) and shared (everyone has them); click either to see its files. The count in the top bar is yours too, and Commit and push commits only your files, leaving everyone else's for them.
+
 ## 0.3.108 — 2026-10-19
 
 - **A git reset over a held file isn't taken as your change.** Moving your branch to a commit from elsewhere (a release made in another clone, say) with `git reset` leaves your files as they were. For a file someone else held, Quilt then measured your copy from the new commit, so it looked as if you had taken that commit's change out: a merge appeared under your name, and the change was briefly removed when they let go. Your copy is now measured from the commit it came from, so nothing is recorded, and the commit's change comes in once they let go.

package/bin/quilt.js

@@ -558,6 +558,7 @@ async function say () {
 async function workspaceCmd () {
   const { WORKSPACE_USAGE, runWorkspaceCommand } = await import('../src/workspace-cli.js')
   const [sub, ...rest] = argv
+  if (!(await import('../src/app-workspaces.js')).appWorkspaces()) fail('Workspaces are turned off in this version of Quilt.')
   if (!sub || sub === 'help' || sub === '--help' || sub === '-h') return console.log(WORKSPACE_USAGE)
   const { localWorkspaceAccess } = await import('../src/mcp.js')
   const { findDaemon } = await import('../src/control.js')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyquilt",
-  "version": "0.3.108",
+  "version": "0.3.109",
   "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/ai-vm.js

@@ -74,6 +74,53 @@ export async function warmTool (exe, stop = () => false) {
   return warmFolder(root, BIG_FILE, stop)
 }
 
+// What the image installed into a home folder of its own for every machine (vm/Dockerfile: caveman
+// for Claude Code, Codex and Cursor); each machine's home (its volume) takes it in at start.
+export const IMAGE_HOME = '/opt/cavehome'
+
+/** Two settings files as one: `over`'s keys added to `base`, objects merged, lists joined, `base` kept where both say. */
+function mergeJson (base, over) {
+  if (Array.isArray(base) && Array.isArray(over)) return [...base, ...over.filter((x) => !base.some((y) => JSON.stringify(y) === JSON.stringify(x)))]
+  if (!base || !over || typeof base !== 'object' || typeof over !== 'object' || Array.isArray(base) || Array.isArray(over)) return base
+  const out = { ...base }
+  for (const [k, v] of Object.entries(over)) out[k] = k in base ? mergeJson(base[k], v) : v
+  return out
+}
+
+/**
+ * Takes in what the image installed for every machine (`from`) into this machine's home (`to`):
+ * files it lacks are copied, JSON settings it has are merged (its own kept where both say), and
+ * nothing of its own is replaced. Returns how many files changed.
+ */
+export function seedHome (from, to) {
+  let n = 0
+  const walk = (rel) => {
+    let entries = []
+    try { entries = fs.readdirSync(path.join(from, rel), { withFileTypes: true }) } catch { return }
+    for (const e of entries) {
+      const r = path.join(rel, e.name)
+      const src = path.join(from, r)
+      const dst = path.join(to, r)
+      if (e.isDirectory()) { walk(r); continue }
+      if (!e.isFile()) continue
+      try {
+        if (!fs.existsSync(dst)) {
+          fs.mkdirSync(path.dirname(dst), { recursive: true })
+          fs.copyFileSync(src, dst)
+          fs.chmodSync(dst, fs.statSync(src).mode & 0o777)
+          n++
+        } else if (e.name.endsWith('.json')) {
+          const have = JSON.parse(fs.readFileSync(dst, 'utf8'))
+          const merged = mergeJson(have, JSON.parse(fs.readFileSync(src, 'utf8')))
+          if (JSON.stringify(merged) !== JSON.stringify(have)) { fs.writeFileSync(dst, JSON.stringify(merged, null, 2) + '\n'); n++ }
+        }
+      } catch {}
+    }
+  }
+  walk('')
+  return n
+}
+
 /** Reads every file of `min` bytes or more under `root` into memory, until `stop()`; returns how many bytes. */
 export async function warmFolder (root, min = 0, stop = () => false) {
   let bytes = 0
@@ -114,10 +161,11 @@ export class AiVm {
    * reaches outside is injectable for tests: `fetch`, `login` (spawnLogin), `status` (runQuiet),
    * `join` (runSession), `agentJoin`/`agentAccess` (agent-join.js), `autowork`, `which`.
    */
-  constructor ({ api, joinLink = '', spareKey = '', home = process.env.HOME, fetch: fetchImpl = globalThis.fetch, login = spawnLogin, status = runQuiet, warm = warmTool, join = null, agent = null, autowork = null, which = null, now = Date.now, log = console.log, idleMs = IDLE_MS, reportMs = REPORT_MS, port = 8080, waitParam = '1', claimEveryMs = CLAIM_EVERY_MS, codeMs = CODE_MS }) {
+  constructor ({ api, joinLink = '', spareKey = '', imageHome = null, home = process.env.HOME, fetch: fetchImpl = globalThis.fetch, login = spawnLogin, status = runQuiet, warm = warmTool, join = null, agent = null, autowork = null, which = null, now = Date.now, log = console.log, idleMs = IDLE_MS, reportMs = REPORT_MS, port = 8080, waitParam = '1', claimEveryMs = CLAIM_EVERY_MS, codeMs = CODE_MS }) {
     this.api = String(api || '').replace(/\/+$/, '')
     this.joinLink = joinLink
     this.spareKey = spareKey
+    this.imageHome = imageHome
     this.warm = warm
     this.claimEveryMs = claimEveryMs
     this.codeMs = codeMs
@@ -235,6 +283,8 @@ export class AiVm {
 
   async start () {
     fs.mkdirSync(this.dir, { recursive: true })
+    // What the image installed for every machine (caveman for each AI tool) comes into this home.
+    if (this.imageHome) { const n = seedHome(this.imageHome, this.home); if (n) this.log(`took in ${n} file(s) of the image's tool settings`) }
     if (this.spareKey && !(await this.hasAgent())) await this.spare()
     if (this.stopped) return
     await this.ensureAgent()
@@ -512,7 +562,7 @@ export function onPath (names, { env = process.env } = {}) {
 /** `quilt ai-vm`, from the machine's environment. */
 export async function runAiVm (env = process.env) {
   if (!env.QUILT_API) throw new Error('QUILT_API is not set: this command runs on a cloud AI machine Quilt started.')
-  const vm = new AiVm({ api: env.QUILT_API, joinLink: env.QUILT_AI_VM_JOIN || '', spareKey: env.QUILT_AI_VM_SPARE || '', home: env.HOME, which: (names) => onPath(names), port: Number(env.PORT || 8080) })
+  const vm = new AiVm({ api: env.QUILT_API, joinLink: env.QUILT_AI_VM_JOIN || '', spareKey: env.QUILT_AI_VM_SPARE || '', imageHome: fs.existsSync(IMAGE_HOME) ? IMAGE_HOME : null, home: env.HOME, which: (names) => onPath(names), port: Number(env.PORT || 8080) })
   const shutdown = async () => { await vm.stop(); process.exit(0) }
   process.on('SIGINT', shutdown)
   process.on('SIGTERM', shutdown)

package/src/api/server.js

@@ -41,8 +41,7 @@ import { roomAccessFrom } from './access.js'
 import { joiningRoom, sessionArg } from '../mcp-room.js'
 import { issueRoutes } from './routes/issues.js'
 import { aiVmRoutes, cloudAiOf, WAIT_MS as AI_VM_WAIT_MS } from './routes/ai-vm.js'
-import { personaName } from '../persona.js'
-import { CLOUD_LABEL } from '../cloud-ai.js'
+import { aiName } from '../persona.js'
 import { routeName, cleanEvent } from './issues.js'
 import { secretRoutes } from './routes/secrets.js'
 
@@ -146,8 +145,8 @@ 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 one of its person's
-   * AI sessions: named like one ("Dan · cloud"), with its person's account (`of`) and name
+   * 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.
    */
   async function agentHolder (agent) {
@@ -156,7 +155,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: personaName(person, CLOUD_LABEL).slice(0, 64), of: `person:${vm.userId}`, ofName: person }
+    return { ...holder, 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/app-workspaces.js

@@ -0,0 +1,4 @@
+// Workspaces are off on this computer until after the MVP (the cofounders' call, 2026-10-19): the
+// app, its agents' workspace tools and `quilt workspace` act as if the accounts API had them off,
+// whatever the API says. QUILT_APP_WORKSPACES=1 brings them back (tests, and when they return).
+export const appWorkspaces = (env = process.env) => /^(1|true)$/i.test(env.QUILT_APP_WORKSPACES || '')

package/src/autowork.js

@@ -62,8 +62,12 @@ export function tokensOn (entries, ts) {
   return Object.values(d).reduce((n, t) => n + t.input + t.output, 0)
 }
 
-/** What a run is asked to do: the work, and how to talk while nobody watches. */
-export function runPrompt ({ person, job, changeFiles, prompt = '' }) {
+/**
+ * What a run is asked to do: the work, and how to talk while nobody watches. `voice`: the
+ * 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 || '' }) {
   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.`,
     ''
@@ -76,6 +80,7 @@ export function runPrompt ({ person, job, changeFiles, prompt = '' }) {
       `Answer ${job.by || 'them'} with quilt_message. If they ask for work, do it as ${person}'s AI would, and say in chat what you did.`)
   }
   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.`)
   lines.push(
@@ -291,7 +296,7 @@ export class AutoWork {
   fail (session, run, why) {
     const where = session.aiOf ? 'your cloud AI (Settings → Your AI)' : 'this computer'
     const text = SIGNED_OUT.test(String(why)) ? `${run.tool || 'your AI tool'} isn't signed in on ${where}` : String(why).replace(/[.\s]+$/, '').slice(0, 300)
-    this.notice(session, `Couldn't run your AI for ${run.title || 'that work'}: ${text}. It's still waiting for your AI in your chat.`, run)
+    this.notice(session, `Couldn't run your AI for ${run.title || 'that work'}: ${text}. It's still waiting for your AI.`, run)
     session.dropAutoPersona(run.via)
   }
 

package/src/cloud-ai.js

@@ -1,13 +1,10 @@
-// A person's AI on its own cloud machine (docs/superpowers/specs/2026-10-17-ai-vm.md) is one of
-// that person's AI sessions: its presence says whose (`aiOf`), and it answers for
-// "<person>'s AI" only while none of the person's AI sessions on a computer is live. Pure, so
-// the relay (which wakes a suspended one) and every app (which shows it and reads its inbox)
-// decide the same way.
+// A person's AI on its own cloud machine (docs/superpowers/specs/2026-10-17-ai-vm.md): its
+// presence says whose (`aiOf`), and it is the only "<person>'s AI": that is its name, and what
+// is written to it or handed to the person's AI is its, whether or not they have AI sessions
+// open on a computer (those answer only to their own names). Pure, so the relay (which wakes a
+// suspended one) and every app (which shows it and reads its inbox) decide the same way.
 import { aiName } from './ui/chat.js'
 
-/** The label a cloud AI's name carries: "Daniel · cloud". */
-export const CLOUD_LABEL = 'cloud'
-
 /**
  * Whether one of `person`'s AI sessions on a computer is live: a presence of theirs (not a
  * cloud AI's) publishing an AI session that isn't a "work on its own" run.
@@ -31,17 +28,17 @@ export function localAiNames (states, person) {
 }
 
 /**
- * How a cloud AI named `name`, of `person`, reads the inbox (inbox.js): its own name always;
- * "<person>'s AI" and tasks for it only while no AI session of theirs on a computer is live.
+ * How a cloud AI named `name`, of `person`, reads the inbox (inbox.js): its own name and
+ * "<person>'s AI" (the same, once it has rejoined under it), and tasks for the person's AI.
+ * Its person's AI sessions on computers don't wake it: they work for the same person.
  */
 export function cloudReader ({ name, person, states = [], aliases = [] }) {
-  const local = localAiLive(states, person)
   return {
     name,
-    aliases: local ? [...aliases] : [...aliases, aiName(person)],
+    aliases: [...new Set([...aliases, aiName(person)])].filter((n) => n !== name),
     agent: true,
     asAi: false,
-    ...(local ? {} : { of: person }),
+    of: person,
     own: localAiNames(states, person)
   }
 }

package/src/hooks.js

@@ -157,8 +157,8 @@ async function sessionStart (api, state, say, name) {
   // Only what arrives from now on is for this Claude; what came before is for quilt_inbox.
   const { seq } = await api('POST', '/inbox', { after: 0 }).catch(() => ({ seq: 0 }))
   state.update((s) => { s.after = seq || 0 })
-  // A person's AI sessions are one name to people: "Daniel's AI (3 sessions)".
-  const who = st.peers.length ? foldPersonas(st.peers).map((p) => p.sessions ? `${p.name} (${p.sessions.length === 1 ? 'one AI session' : `${p.sessions.length} AI sessions`}${p.mine ? ', you among them' : ''})` : p.name + (p.kind === 'agent' ? ' (AI agent)' : '')).join(', ') : 'nobody else yet'
+  // Each AI session is a member by its own name.
+  const who = st.peers.length ? foldPersonas(st.peers).map((p) => p.name + (p.aiOf ? ` (${p.mine ? 'one of your person\'s AI sessions' : `an AI session of ${p.aiOf}`})` : p.kind === 'agent' ? ' (AI agent)' : '')).join(', ') : 'nobody else yet'
   const parts = [
     `This folder is in a live Quilt session (room ${st.room}) with ${who}. Files can change underneath you at any time; re-read a file right before editing it.`,
     'Quilt claims each file for you the moment you edit it, and releases those claims when you finish. ' +
@@ -167,7 +167,7 @@ async function sessionStart (api, state, say, name) {
     'When someone asks for a file you hold, finish your change, then hand it off with quilt_handoff and your context; you cannot finish before you do.',
     'Messages from collaborators, mentions of you and tasks handed to you are shown to you as you work; answer with quilt_message and take a task with quilt_move_task.',
     'You are a member of your own in the session, apart from your person and their other AI sessions, named after your work (your git branch, or the first thing you say you are doing); rename yourself with quilt_name_session. ' +
-    'People see all of a person\'s AI sessions as one, "<person>\'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).'
+'People 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 (Quilt runs their own AI tool for them on their own cloud machine): write to it by that name. 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).'
   ]
   const duties = await api('GET', '/duties').catch(() => ({}))
   if (duties.pickup && duties.pickup !== 'off') parts.push(`This person lets you pick up work from the task board by yourself (${duties.pickup === 'any' ? 'tasks assigned to you, then unassigned ones' : 'tasks assigned to you'}): when you finish, you are handed the next one.`)

package/src/inbox.js

@@ -101,7 +101,8 @@ export function scanInbox ({ messages = [], tasks = [], reader, now = Date.now()
     else if (follows) events.push({ id: m.id, kind: 'mention', by: m.by, text, ts: m.ts, follows })
   }
   const mine = []
-  for (const t of tasks) {
+  // `tasks: false`: a person's own inbox on a computer takes no tasks (their AI asks the board).
+  for (const t of reader && reader.tasks === false ? [] : tasks) {
     // An AI session's tasks: given to it by name (as a member), or to its person's AI.
     const its = assignedToReader(t, reader) || names.slice(1).some((n) => assignedToReader(t, { ...reader, name: n })) ||
       (reader && reader.of && (t.assignee === me || assignedToReader(t, { name: reader.of, asAi: true })))

package/src/mcp.js

@@ -40,6 +40,7 @@ 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'
+import { appWorkspaces } from './app-workspaces.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)
@@ -79,7 +80,7 @@ export const MCP_INSTRUCTIONS =
   'and move a task with quilt_move_task when you start or finish it; quilt_task reads one in full with its comments, and quilt_comment_task leaves a note or handoff on it. ' +
   'quilt_history tells you who changed which file, when, with the diff: read it for the files you are about to touch. ' +
   'If git refuses to pull because untracked files would be overwritten, those files came from the session: quilt_status lists them under Pulling (and whether they match); make way and pull with rm <files> && git pull --autostash, and Quilt keeps them for everyone. ' +
-  'If the person you work for lets their AI pick up work by itself (their Quilt settings: on their own computer, or on their own cloud VM they connected), finishing (quilt_set_work done, a task to QA or Done) hands you your next task from the board: start it. ' +
+  'If the person you work for lets their AI pick up work by itself (their cloud AI, on the cloud machine they connected), finishing (quilt_set_work done, a task to QA or Done) hands you your next task from the board: start it. ' +
   'Before you change files, call quilt_before_edit with their paths: it tells you whether each is yours to edit (claiming free ones for you, so partners are refused instead of overwriting you), ' +
   'and shows what people said about those files in chat, so you know what was asked or planned before you change them. ' +
   'Do not edit a file it refuses: ask for it in its file queue with quilt_request_file (a title like "Working on <what> for <task>" and up to 300 characters on your plan) and carry on with other work; you are woken when it is handed to you, with the holder\'s context. ' +
@@ -104,7 +105,7 @@ export const MCP_INSTRUCTIONS =
   '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. ' +
   'To be woken instead of polling, subscribe to the quilt://inbox resource (you are told when something new arrives), or quilt_webhook_subscribe POSTs each one to a URL of yours as it happens. ' +
-  '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). ' +
+  '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 each AI session by its own name. "<person>\'s AI" ("Daniel\'s AI") is only that person\'s cloud AI, when they connected one (Quilt runs their own AI tool for them on their own cloud machine): write to it by that name. 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). ' +
   '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 + ' ' +
@@ -237,7 +238,7 @@ export async function runMcp () {
     inputSchema: {
       title: z.string().describe('What needs doing, in a few words'),
       assignee: z.string().optional().describe('Who should do it: a person\'s name, or "me". Omit to leave it unassigned.'),
-      to_ai: z.boolean().optional().describe('Assign it to that person\'s AI instead of the person. You are this person\'s AI unless you joined as your own agent: set assignee to "me" and to_ai to true to take the task yourself.'),
+      to_ai: z.boolean().optional().describe('Assign it to that person\'s AI (their cloud AI, when they connected one) instead of the person. To take a task yourself, set assignee to your own name.'),
       files: z.array(z.string()).max(20).optional().describe('Project files this task is about, relative paths such as src/app.js')
     }
   }, ({ title, assignee, to_ai, files }) => withDaemon(async (d) => {
@@ -281,7 +282,7 @@ export async function runMcp () {
   }, { gate: gates(gateFor('quilt_move_task'), column === 'done' && queueGate('move the task again')) }))
 
   server.registerTool('quilt_assign_task', {
-    description: 'Assign a shared task to a person or to their AI, and optionally set the files it is about. assignee "" clears it. Set assignee to "me" and to_ai to true to take it yourself when you are that person\'s AI.',
+    description: 'Assign a shared task to a person, an AI session (by its own name) or a person\'s AI (their cloud AI), and optionally set the files it is about. assignee "" clears it. To take it yourself, set assignee to your own name.',
     inputSchema: {
       id: z.string().describe('Task id from quilt_tasks'),
       assignee: z.string().describe('A person\'s name, "me", or "" to unassign'),
@@ -1201,12 +1202,13 @@ export async function workspacesOn (api, fetchImpl = globalThis.fetch) {
 }
 
 /**
- * Adds the workspace library tools when there is someone to act as (workspaceActor: this
- * folder's agent, or the person signed in on this computer) and their API says workspaces are
- * on. Anything else (nobody, the flag off, the API slow, unreachable or odd) adds nothing and
+ * Adds the workspace library tools when workspaces are on on this computer (app-workspaces.js),
+ * there is someone to act as (workspaceActor: this folder's agent, or the person signed in on
+ * this computer) and their API says workspaces are on. Anything else (nobody, the flag off, the API slow, unreachable or odd) adds nothing and
  * never throws. Returns whether the tools were added.
  */
 export async function addWorkspaceTools (server, { fetch: fetchImpl = globalThis.fetch, projectDirs = () => [process.cwd()] } = {}) {
+  if (!appWorkspaces()) return false // off on this computer (app-workspaces.js)
   const access = localWorkspaceAccess({ fetch: fetchImpl, projectDirs })
   let api
   try { api = access.api() } catch { return false }

package/src/persona.js

@@ -97,5 +97,5 @@ export function labelFromFile (rel) {
   return cleanLabel(base.replace(/\.[A-Za-z0-9]+$/, ''))
 }
 
-// "Daniel's AI": all of a person's AI sessions as one name (pure, shared with the app).
+// "Daniel's AI": a person's cloud AI's name, and only that (pure, shared with the app).
 export { AI_SUFFIX, aiName, foldPersonas } from './ui/chat.js'

package/src/relay-mcp.js

@@ -34,7 +34,6 @@ import { UpdateCheck } from './update-check.js'
 import { TASK_WORKFLOW, pickupBrief, doneRefusal, verifiedEnough, verifiedLine, qaRefusal, qaNotesEnough, qaNotesLine, pickChecklist, MAX_VERIFIED } from './agent-task-workflow.js'
 import { HistoryLog, queryHistory, parseSince, formatHistory, currentTask, lineDiff } from './history.js'
 import { changeRefusal, TALK_REFUSED } from './session-access.js'
-import { aiName } from './persona.js'
 import { chatAbout, renderChatAbout, waitingOn, needsNoReply, renderUnanswered, heldRefusal, queuedFor, renderQueueNotice, renderQueued, answered, unaddressed, CHAT_RULES, RE_HELP, replyFor, renderReplied } from './duties.js'
 import { describeSubscription, WEBHOOK_EVENTS } from './webhooks.js'
 import { registerWorkspaceTools, bytesFetcher, WORKSPACE_GUIDE_HOSTED } from './workspace-tools.js'
@@ -268,7 +267,6 @@ function sessionTools (server, ctx) {
   // Everyone this agent could address: who is here and who has been in the chat.
   const memberNames = (room, doc) => {
     const names = new Set(peers(room).map((p) => p.name))
-    for (const p of peers(room)) if (p.persona && p.of) names.add(aiName(p.of)) // "Daniel's AI"
     for (const m of seen(doc)) { 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)

package/src/session.js

@@ -5337,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 } : {}) }
   }
 
   /**
@@ -5374,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. */
@@ -5414,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))
@@ -5435,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)
@@ -5608,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)
@@ -5721,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
@@ -5959,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
@@ -5986,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. */
@@ -6008,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. */
@@ -6135,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) {
@@ -6160,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 } : {}) }
   }
@@ -6328,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).

package/src/ui/session.js

@@ -199,6 +199,7 @@ export function mountSession (id) {
   bindTop()
   bindAccess()
   bindChanges(id, mounted.signal, { onOpen: (path) => openFile(path, { tab: 'changes' }), close: () => setGitOpen(false), onCount: renderGitChip })
+  loadMine(true)
   bindCatchUp($('#catchup'), { sessionId: () => current, onOpen: openFile })
   bindGithubCard()
   bindMain()
@@ -263,6 +264,7 @@ export function sessionUpdated (id) {
   if (ws(id).mode === 'tasks') paintBoard()
   scheduleTree()
   changesChanged()
+  loadMine()
 }
 
 export function sessionMessage (id) {
@@ -299,6 +301,7 @@ export function sessionFileChanged (id, { path }) {
   if (id !== current) return
   scheduleTree()
   changesChanged()
+  loadMine()
   const w = ws(id)
   if (w.fileTabs.includes(path)) {
     if (w.mode === 'files' && w.fileSel === path) { refreshFile(path, true); scheduleHistory(path) } else { w.stale[path] = true; histories.delete(fileKey(path)); renderMainBar() }
@@ -681,6 +684,33 @@ function renderTop () {
 // request has a Commit button (exactly its files, then a push). "Not committed yet" shows the
 // uncommitted work here by who made it, so nothing finished sits unshipped unnoticed.
 let commitGithub = null // the owner's GitHub connection (GET /api/github), while the panel is open
+// Your own work not committed here (GET mine-uncommitted: yours and your AIs', each boxed or not),
+// for the git chip's count and the panel. Nobody else's: they commit their own.
+let mineView = { id: null, data: null, at: 0, loading: false, again: false, open: new Set(['boxed']) }
+const MINE_FRESH_MS = 3000 // fetched again at most this often as the session changes
+
+function loadMine (force = false) {
+  const id = current
+  if (!id) return
+  if (mineView.id !== id) mineView = { id, data: null, at: 0, loading: false, again: false, open: new Set(['boxed']) }
+  if (mineView.loading) { mineView.again = true; return }
+  const wait = MINE_FRESH_MS - (Date.now() - mineView.at)
+  if (!force && wait > 0) { clearTimeout(loadMine.timer); loadMine.timer = setTimeout(() => loadMine(true), wait); return }
+  mineView.loading = true
+  api('GET', `/api/sessions/${id}/mine-uncommitted`).then((r) => {
+    if (mineView.id !== id) return
+    mineView.data = r && Array.isArray(r.files) ? r : null
+    mineView.at = Date.now()
+    renderGitChip()
+  }, () => {}).finally(() => {
+    if (mineView.id !== id) return
+    mineView.loading = false
+    if (mineView.again) { mineView.again = false; loadMine() }
+  })
+}
+
+/** How many of your own files aren't committed here (null before the first look, or without git). */
+const mineCount = () => (mineView.id === current && mineView.data ? mineView.data.files.length : null)
 /** Session settings: GitHub sync, large files through the relay, and git for this session. */
 async function gitSettingChange (e) {
   if (e.target.matches('[data-large-to-relay]')) {
@@ -712,7 +742,7 @@ function setGitOpen (open) {
   if (!panel) return
   panel.hidden = !open
   $('#git-chip').setAttribute('aria-expanded', String(open))
-  if (open) { renderBranchMenu(); renderCommitPanel(); loadCommitWork(); loadChanges() }
+  if (open) { renderBranchMenu(); renderCommitPanel(); loadCommitWork(); loadChanges(); loadMine(true) }
 }
 
 function bindCommitChip () {
@@ -731,14 +761,20 @@ function bindCommitChip () {
     btn.disabled = true
     btn.textContent = 'Committing…'
     try {
-      const r = await api('POST', `/api/sessions/${current}/commit-session`, { message: input.value })
+      const r = await api('POST', `/api/sessions/${current}/commit-session`, { message: input.value, mine: true })
       toast(r.hash ? `Committed ${r.hash.slice(0, 7)}${r.pushed ? ' and pushed' : `; not pushed: ${r.pushError || 'no upstream'}`}` : 'Already in git')
       input.value = ''
+      loadMine(true)
     } catch (err) { toast(err.message) } finally {
       btn.disabled = false
       btn.textContent = 'Commit and push'
     }
   })
+  // Which of your two lines (boxed, shared) is open stays so across redraws.
+  panel.addEventListener('toggle', (e) => {
+    const d = e.target.closest && e.target.closest('[data-mine-group]')
+    if (d) d.open ? mineView.open.add(d.dataset.mineGroup) : mineView.open.delete(d.dataset.mineGroup)
+  }, true)
   panel.addEventListener('click', async (e) => {
     if (e.target.closest('[data-gh-connect]')) { connectGithub(); return }
     const live = e.target.closest('[data-open-live]')
@@ -796,17 +832,19 @@ function renderGitChip () {
   const dot = $('#git-dot')
   dot.hidden = !!say || !(live && live.dot)
   dot.className = `sd${live && live.dot ? ` ${live.dot}` : ''}`
-  const n = changedCount()
+  const own = mineCount()
+  const n = own === null ? changedCount() : own
   const branch = $('#git-branch')
+  $('#chg-count').textContent = n
   $('#git-chg').hidden = !n
   $('#git-sep').hidden = branch.hidden || !n
   const lines = [
     branch.hidden ? '' : branch.dataset.title,
-    n ? `${n} file${n === 1 ? '' : 's'} changed in this session.` : '',
+    n ? own === null ? `${n} file${n === 1 ? '' : 's'} changed in this session.` : `${n} file${n === 1 ? '' : 's'} of yours not committed.` : '',
     open.length ? open.map((r) => `${r.by}: ${r.message}`).join('\n') : live ? live.line : gh ? githubWords(gh) : ''
   ].filter(Boolean)
   chip.title = [...lines, 'Click for branches, GitHub and every change.'].join('\n')
-  chip.setAttribute('aria-label', `Source control${branch.hidden ? '' : `: ${st.git.key}`}${n ? `, ${n} changed` : ''}${say ? `, ${say}` : live ? `, ${live.chip}` : ''}`)
+  chip.setAttribute('aria-label', `Source control${branch.hidden ? '' : `: ${st.git.key}`}${n ? own === null ? `, ${n} changed` : `, ${n} of yours not committed` : ''}${say ? `, ${say}` : live ? `, ${live.chip}` : ''}`)
   if (!$('#git-panel').hidden) renderCommitPanel()
 }
 
@@ -829,6 +867,7 @@ function renderCommitPanel () {
   // (sync, large files, what agents may commit) live in Session settings.
   const html = `
     ${open.length ? `<h4>Asked to be committed</h4><ul class="commit-reqs">${open.map(req).join('')}</ul>` : ''}
+    ${mineHtml(st)}
     ${gitLineHtml(st)}
     ${connectHtml(st)}
     ${open.length > 1 ? '<div class="commit-foot"><button type="button" class="btn sm ghost" data-done="all">Close all</button></div>' : ''}`.trim()
@@ -873,20 +912,33 @@ function syncWords (st) {
   return { chip: 'Not syncing', line: `${(s.why || `sync of ${name} with GitHub is off`).replace(/^./, (c) => c.toUpperCase())}.`, warn: false, off: true }
 }
 
+/**
+ * Your own work not committed here, in two lines (mockup option B): what is boxed (in your folder
+ * only so far) and what everyone already has; each opens to its files. Then the commit, which
+ * takes only these. Nobody else's work is counted or listed.
+ */
+function mineHtml (st) {
+  const files = mineView.id === current && mineView.data ? mineView.data.files : null
+  if (!files) return ''
+  if (!files.length) return '<div class="mw-head"><h4>Not committed</h4></div><p class="mw-none">Nothing of yours: your work here is all in git.</p>'
+  const boxed = files.filter((f) => f.boxed)
+  const shared = files.filter((f) => !f.boxed)
+  const group = (key, list, ico, label, hint) => list.length
+    ? `<details class="mw" data-mine-group="${key}"${mineView.open.has(key) ? ' open' : ''}><summary><span class="mw-ico">${ico}</span><span>${list.length} ${label}</span><span class="hint">${hint}</span></summary><ul>${list.map((f) => `<li><code title="${esc(f.path)}">${esc(f.path)}</code></li>`).join('')}</ul></details>`
+    : ''
+  return `<div class="mw-head"><h4>Not committed</h4></div>
+    ${group('boxed', boxed, I.box, 'boxed', 'only in your folder')}
+    ${group('shared', shared, '<span class="mw-dot"></span>', 'shared', 'everyone has them')}
+    ${st.canCommit ? `<form class="cp-commit" data-commit-session><input class="input" name="message" placeholder="Commit message" aria-label="Commit message" maxlength="500" required autocomplete="off"><button type="submit" class="btn sm primary">Commit and push</button></form>` : ''}`
+}
+
 /** The session against GitHub in a line (the long words on hover), and the commit that sends what isn't there yet. */
 function gitLineHtml (st) {
   const w = syncWords(st)
   if (!w || w.off) return ''
   const b = myBranchOf(st)
-  if (w.pending) {
-    const s = b.relay.sync
-    const n = s.pending || 0
-    const gh = githubStateOf(st)
-    const sha = s.revision ? s.revision.slice(0, 7) : ''
-    const commit = !sha ? '' : gh ? `<a href="https://github.com/${esc(gh.repo)}/commit/${esc(s.revision)}" target="_blank" rel="noreferrer">${sha}</a>` : `<code>${sha}</code>`
-    return `<p class="cp-line" title="${esc(w.line)}"><span class="sd edit"></span><span>${n} file${n === 1 ? '' : 's'} not committed${sha ? ` · GitHub at ${commit}` : ''}</span></p>
-      ${st.canCommit ? `<form class="cp-commit" data-commit-session><input class="input" name="message" placeholder="Commit message" aria-label="Commit message" maxlength="500" required autocomplete="off"><button type="submit" class="btn sm primary">Commit and push</button></form>` : ''}`
-  }
+  // Work not on GitHub yet: what is yours shows above (mineHtml); everyone else's is theirs to commit.
+  if (w.pending) return ''
   const pr = w.pr ? (w.pr.url ? ` · <a href="${esc(w.pr.url)}" target="_blank" rel="noreferrer">pull request #${w.pr.number}</a>` : '') : ''
   const live = w.liveIn ? ` <button type="button" class="btn sm" data-open-live="${esc(w.liveIn)}">Open the live session</button>` : ''
   return `<p class="cp-line${w.warn ? ' warn' : ''}" title="${esc(w.line)}">${w.dot ? `<span class="sd ${w.dot}"></span>` : ''}<span>${esc(w.chip)}</span>${pr}${live}</p>`

package/src/ui-server.js

@@ -22,8 +22,7 @@ import { autowork, autoConfig, publicConfig, AUTO_MODES } from './autowork.js'
 import { migrateDir } from './legacy.js'
 import { writePrivateJson } from './private-file.js'
 import { readAccount, saveAccount, workspaceGithub, setWorkspaceGithub, removeWorkspaceGithub, setOrgGithub, clearAccount, clearAccountIf, resumeAccount, startLink, waitForLink, fetchMe, signOut, revokeToken, accountFromProfile, renameSession, createAgentInvite, listAgents, listAccessTypes, listCollaborators, listGrants, putGrant, deleteGrant, inviteToSession, listSessionInvites, cancelSessionInvite, listWorkspaces, listOrgs, createWorkspace, getWorkspace, updateWorkspace, deleteWorkspace, putWorkspaceMember, removeWorkspaceMember, getAgentPlacement, putAgentPlacement, listOrgAgents, putWorkspaceAgent, deleteWorkspaceAgent, createWorkspaceAgentInvite, excludeSessionAgent, listExcludedSessionAgents, listSessionAgents, includeSessionAgent, setSessionWorkspace, moveSessionToWorkspace, listWorkspaceInvites, inviteToWorkspace, cancelWorkspaceInvite, listMyInvites, answerMyInvite, announceSessionStarted, announceWhenReported, listWorkspaceFiles, createWorkspaceFile, confirmWorkspaceFile, workspaceFileDownload, updateWorkspaceFile, deleteWorkspaceFile, createWorkspaceFolder, listWorkspaceFileVersions, githubStatus, githubConnectUrl, listSandboxKeys, createSandboxKey, rotateSandboxKey, revokeSandboxKey, removeSandboxKey, aiVmFollow, aiVmUnfollow, aiVmStatus, aiVmConnect, aiVmUpdate, aiVmSignIn, aiVmWake, aiVmDisconnect, apiUrl } from './account.js'
-import { personaName } from './persona.js'
-import { CLOUD_LABEL } from './cloud-ai.js'
+import { aiName } from './persona.js'
 import { effectiveAccess, builtinType } from './session-access.js'
 import { cleanSessionName, BAD_SESSION_NAME, SESSION_NAME_MAX } from './session-name.js'
 import { personPasses, personApiAuth } from './pass-source.js'
@@ -35,6 +34,7 @@ import { queryHistory } from './history.js'
 import { contentDisposition } from './api/file-paths.js'
 import { getSecrets, putSecretSettings, setSecretWho, deleteSecret, secretUses, saveSecrets, secretAsks, answerAsk } from './secrets-client.js'
 import { envFilesIn, knownEnvFile, envValues } from './secret-import.js'
+import { appWorkspaces } from './app-workspaces.js'
 
 const TOOL_NAMES = ['Claude Code', 'Cursor', 'Codex', 'xAI', 'Windsurf', 'GitHub Copilot', 'Zed', 'Aider', 'Other']
 const MAX_WS_FILE_BYTES = 500 * 1024 * 1024
@@ -558,7 +558,7 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
     // A session nobody named is shown as the app shows it: by this computer's folder for it.
     const local = new Map([...runs.values()].filter((e) => e.run && e.run.session).map((e) => [e.run.session.room, e.run.session.sessionName || path.basename(e.run.dir || '')]))
     const sessions = (vm.sessions || []).map((x) => (x.name ? x : { ...x, name: local.get(x.room) || '' }))
-    return { vm: { ...vm, sessions, name: personaName(person, CLOUD_LABEL) } }
+    return { vm: { ...vm, sessions, name: aiName(person) } }
   }
   const cloudNone = (err) => { if (err.status === 404) return cloudView(null); throw err }
   /** What Settings may change: the tool, model, instructions and daily cap (blank is no cap). */
@@ -615,7 +615,8 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
   }
 
   // Workspaces live on the accounts API behind a flag: a 404 means off, and the app shows today's home.
-  const workspaceList = () => asAccount(async (token) => {
+  // Off on this computer (app-workspaces.js) whatever the API says.
+  const workspaceList = () => !appWorkspaces() ? (workspacesOn = false, { on: false, workspaces: [] }) : asAccount(async (token) => {
     try {
       const workspaces = await listWorkspaces({ token })
       workspacesOn = true
@@ -799,7 +800,7 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
       try {
         const res = await fetch(`${apiUrl()}/v1/features`, { signal: AbortSignal.timeout(5000) })
         const f = res.ok ? await res.json() : {}
-        return { secrets: !!f.secrets, workspaces: !!f.workspaces }
+        return { secrets: !!f.secrets, workspaces: !!f.workspaces && appWorkspaces() }
       } catch { return { secrets: false, workspaces: false } }
     },
     'POST /api/secrets/env-scan': (b) => {
@@ -893,7 +894,7 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
     }),
     'POST /api/workspaces/:id/invites/:iid/cancel': (b, id, url, iid) => asAccount(async (token) => { await cancelWorkspaceInvite({ token, id: needWorkspaceId(id), inviteId: needInviteId(iid) }); return { ok: true } }),
     // Invites waiting for you (workspaces, and sessions with their link); accept or decline them.
-    'GET /api/invites': () => asAccount(async (token) => ({ invites: await listMyInvites({ token }) })),
+    'GET /api/invites': () => asAccount(async (token) => ({ invites: (await listMyInvites({ token })).filter((i) => i.kind !== 'workspace' || appWorkspaces()) })),
     'POST /api/invites/:id/accept': (b, id) => asAccount(async (token) => answerMyInvite({ token, id: needInviteId(id), how: 'accept' })),
     'POST /api/invites/:id/decline': (b, id) => asAccount(async (token) => answerMyInvite({ token, id: needInviteId(id), how: 'decline' })),
     'GET /api/workspaces/:id/files': (b, id, url) => asAccount(async (token) => ({ files: await listWorkspaceFiles({ token, id: needWorkspaceId(id), folder: url.searchParams.get('folder') ?? undefined }) })),
@@ -1069,13 +1070,15 @@ export async function startUi ({ port = 7420, onShutdown, preview = false, repor
     'GET /api/github/branches': (b, id, url) => gitops.listBranches(url.searchParams.get('repo')),
     'POST /api/sessions/:id/commit-request': (b, id) => { const r = get(id).requestCommit(b.message, { files: Array.isArray(b.files) ? b.files : null, task: b.task || null, by: b.by ? String(b.by).slice(0, 80) : null }); pushStatus(id); return r },
     // Commits a request in this folder (commit.js), and what is not committed here yet, by who made it.
-    'POST /api/sessions/:id/commit-session': async (b, id) => { try { return await get(id).commitSessionWork(String(b.message || '')) } finally { pushStatus(id) } },
+    'POST /api/sessions/:id/commit-session': async (b, id) => { try { return await get(id).commitSessionWork(String(b.message || ''), { mine: b.mine === true }) } finally { pushStatus(id) } },
     'POST /api/sessions/:id/commit-request/commit': async (b, id) => { try { return await get(id).commitRequest(String(b.id || '')) } finally { pushStatus(id) } },
     'POST /api/sessions/:id/agent-commits': async (b, id) => { try { return await get(id).setAgentCommits(b.mode) } finally { pushStatus(id) } },
     'POST /api/sessions/:id/github-sync': async (b, id) => { try { return await get(id).setGithubSync(b.on !== false) } finally { pushStatus(id) } },
     'POST /api/sessions/:id/large-to-relay': async (b, id) => { try { return await get(id).setLargeToRelay(b.on === true) } finally { pushStatus(id) } },
     'POST /api/sessions/:id/github/recheck': async (b, id) => { try { return { github: await get(id).githubRecheck() } } finally { pushStatus(id) } },
     'GET /api/sessions/:id/uncommitted': (b, id) => get(id).uncommittedWork(),
+    // The git panel: your own work not committed here (yours and your AIs'), each boxed or not.
+    'GET /api/sessions/:id/mine-uncommitted': (b, id) => get(id).myUncommitted(),
     'POST /api/sessions/:id/commit-request/done': (b, id) => { const done = get(id).resolveCommitRequests({ ids: b.id ? [String(b.id)] : null }); pushStatus(id); return { done } },
     'GET /api/fs': (b, id, url) => listDir(url.searchParams.get('path') || os.homedir()),
     // Reply first, then shut down, so the page hears back before we exit.