heyquilt 0.3.90 → 0.3.107

package/src/ai-vm.js

@@ -5,14 +5,19 @@
 // tool's own login (ai-vm-signin.js), joins the sessions the person joins, and runs "Work on its
 // own" (autowork.js) there as "<person>'s AI". With nothing to do for a while it asks to be
 // suspended; anything for it resumes the machine where it was.
+//
+// A spare (QUILT_AI_VM_SPARE, a machine made before anyone connects) first reads every AI tool
+// into memory, says it is ready and is suspended; when someone connects it is resumed, asks for
+// its person's one-time join link and goes on as above, every tool already in memory.
 import fs from 'node:fs'
 import path from 'node:path'
 import http from 'node:http'
 import { spawn as spawnChild, execFile } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
 import { quiltHome } from './legacy.js'
 import { saveSettings, relayUrl } from './settings.js'
 import { parseInvite } from './ui/invite.js'
-import { SIGN_IN, readSignIn, keepToken, keptToken, statusSaysSignedIn } from './ai-vm-signin.js'
+import { SIGN_IN, readSignIn, codeRefused, keepToken, keptToken, statusSaysSignedIn } from './ai-vm-signin.js'
 import { tokensOn } from './autowork.js'
 import { writePrivateJson } from './private-file.js'
 
@@ -21,6 +26,12 @@ export const IDLE_MS = 10 * 60 * 1000
 const REPORT_MS = 60 * 1000
 const RETRY_MS = 5 * 1000
 const SIGN_IN_MS = 15 * 60 * 1000 // a sign-in nobody finishes is stopped
+// After a pasted code, how long a tool has to finish before the code counts as not taken.
+const CODE_MS = 20 * 1000
+const CLAIM_EVERY_MS = 500
+const BIG_FILE = 1024 * 1024
+// Quilt's own install (its app folder and the node it runs on), read into memory by a spare too.
+const QUILT_DIRS = [path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'), path.resolve(path.dirname(process.execPath), '..')]
 const ROOM = /^[A-Za-z0-9_-]{1,64}$/
 
 /**
@@ -33,7 +44,11 @@ export function spawnLogin (exe, args, { env = {}, useScript = process.platform
   const [cmd, argv] = useScript
     ? ['script', ['-q', '-f', '-e', '-c', `stty cols 2000 rows 50 2>/dev/null; exec ${[exe, ...args].map(quote).join(' ')}`, '/dev/null']]
     : [exe, args]
-  const child = spawnChild(cmd, argv, { env: { ...process.env, ...env, TERM: 'xterm-256color', BROWSER: 'echo' }, stdio: ['pipe', 'pipe', 'pipe'] })
+  // No BROWSER: with none to open (the machine has none) a tool shows its link at once. Given a
+  // command that "opens" it, Claude waits 3 s for the browser before it prints the link.
+  const all = { ...process.env, TERM: 'xterm-256color', ...env }
+  if (!('BROWSER' in env)) delete all.BROWSER
+  const child = spawnChild(cmd, argv, { env: all, stdio: ['pipe', 'pipe', 'pipe'] })
   const listeners = []
   const onChunk = (d) => { for (const l of listeners) l(String(d)) }
   child.stdout.on('data', onChunk)
@@ -47,6 +62,45 @@ export function spawnLogin (exe, args, { env = {}, useScript = process.platform
   }
 }
 
+/**
+ * Reads a tool's own files into memory, so its first run doesn't wait on the disk: every file of
+ * 1 MB or more in the folder it is installed in (its npm package, or the folder of its program).
+ */
+export async function warmTool (exe, stop = () => false) {
+  let real
+  try { real = fs.realpathSync(exe) } catch { return 0 }
+  let root = path.dirname(real)
+  for (let d = root; d !== path.dirname(d); d = path.dirname(d)) if (fs.existsSync(path.join(d, 'package.json'))) { root = d; break }
+  return warmFolder(root, BIG_FILE, stop)
+}
+
+/** 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
+  const walk = async (dir, depth) => {
+    let entries = []
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }) } catch { return }
+    for (const e of entries) {
+      if (stop()) return
+      const f = path.join(dir, e.name)
+      if (e.isDirectory() && depth < 8) await walk(f, depth + 1)
+      else if (e.isFile()) {
+        try {
+          if (fs.statSync(f).size < min) continue
+          await new Promise((resolve) => {
+            const r = fs.createReadStream(f, { highWaterMark: 4 * 1024 * 1024 })
+            r.on('data', (c) => { bytes += c.length; if (stop()) { r.destroy(); resolve() } })
+            r.on('end', resolve)
+            r.on('error', resolve)
+          })
+        } catch {}
+      }
+    }
+  }
+  await walk(root, 0)
+  return bytes
+}
+
 /** A command's exit code and output (for the tools' status commands); -1 when it can't run. */
 function runQuiet (exe, args) {
   return new Promise((resolve) => {
@@ -60,9 +114,13 @@ 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 = '', home = process.env.HOME, fetch: fetchImpl = globalThis.fetch, login = spawnLogin, status = runQuiet, join = null, agent = null, autowork = null, which = null, now = Date.now, log = console.log, idleMs = IDLE_MS, reportMs = REPORT_MS, port = 8080, waitParam = '1' }) {
+  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 }) {
     this.api = String(api || '').replace(/\/+$/, '')
     this.joinLink = joinLink
+    this.spareKey = spareKey
+    this.warm = warm
+    this.claimEveryMs = claimEveryMs
+    this.codeMs = codeMs
     this.home = home
     this.fetch = fetchImpl
     this.login = login
@@ -98,10 +156,15 @@ export class AiVm {
     return this.agentImpl
   }
 
+  async hasAgent () {
+    const a = await this.agent()
+    try { a.readAgent({ name: AGENT_NAME }); return true } catch { return false }
+  }
+
   /** Joins Quilt as the person's agent with the machine's one-time link, unless it already has. */
   async ensureAgent () {
     const a = await this.agent()
-    try { a.readAgent({ name: AGENT_NAME }); return } catch {}
+    if (await this.hasAgent()) return
     if (!this.joinLink) throw new Error('This machine has no Quilt agent and no link to join with (QUILT_AI_VM_JOIN).')
     await a.join({ link: this.joinLink, name: AGENT_NAME, provider: 'Quilt cloud AI', type: 'cloud AI', description: "A person's AI on its own cloud machine", log: (l) => this.log(l) })
   }
@@ -121,8 +184,59 @@ export class AiVm {
 
   // ------------------------------------------------------------- startup --
 
+  /** The API, as a spare (its key, not an agent's). Short: a request cut by a suspend is given up quickly. */
+  async spareCall (method, route) {
+    const res = await this.fetch(`${this.api}${route}`, { method, headers: { authorization: `Bearer ${this.spareKey}` }, signal: AbortSignal.timeout(1500) })
+    const data = await res.json().catch(() => null)
+    if (!res.ok) throw Object.assign(new Error((data && data.error) || `the API answered ${res.status}`), { status: res.status })
+    return data
+  }
+
+  /**
+   * A spare: reads every tool into memory, says it is ready (and is suspended), then waits to be
+   * taken. Returns when it has its person's one-time join link.
+   */
+  async spare () {
+    const started = this.now()
+    let bytes = 0
+    // Someone may take it while it reads (a person connecting just after the last spare went):
+    // it stops reading then and gets on with their sign-in.
+    const taken = () => !!this.joinLink || this.stopped
+    const watch = setInterval(() => {
+      this.spareCall('GET', '/v1/ai-vm/spare/claim').then((r) => { if (r && r.join && !this.joinLink) { this.joinLink = r.join; this.log('spare: taken while reading the tools') } }, () => {})
+    }, this.claimEveryMs)
+    watch.unref?.()
+    try {
+      for (const t of Object.values(SIGN_IN)) {
+        const exe = this.which(t.exe)
+        if (exe && !taken()) bytes += await this.warm(exe, taken)
+      }
+      // Quilt's own files and the modules it loads once it has a person, so nothing waits on the disk then.
+      if (this.warm === warmTool) for (const d of QUILT_DIRS) if (!taken()) bytes += await warmFolder(d, 0, taken)
+      await Promise.all([import('./agent-join.js'), import('./autowork.js'), import('./runner.js'), import('./pass-source.js')]).catch(() => {})
+    } finally { clearInterval(watch) }
+    if (this.joinLink) return
+    this.log(`spare: the tools are in memory (${Math.round(bytes / 1048576)} MB in ${Math.round((this.now() - started) / 1000)}s)`)
+    // Each "ready" is answered with the join link once someone has taken this machine; until
+    // then the API suspends it (and again, should it ever wake up untaken).
+    let said = false
+    while (!this.stopped && !this.joinLink) {
+      try {
+        const r = await this.spareCall('POST', '/v1/ai-vm/spare/ready')
+        if (!said) this.log('spare: ready')
+        said = true
+        if (r && r.join) { this.joinLink = r.join; this.log('spare: taken'); break }
+      } catch (err) {
+        if (err.status === 401) this.log(`spare: ${err.message}`)
+      }
+      await new Promise((resolve) => setTimeout(resolve, this.claimEveryMs))
+    }
+  }
+
   async start () {
     fs.mkdirSync(this.dir, { recursive: true })
+    if (this.spareKey && !(await this.hasAgent())) await this.spare()
+    if (this.stopped) return
     await this.ensureAgent()
     // A kept Claude token signs Claude's runs in (it never leaves this machine).
     const token = keptToken(this.home, 'Claude Code')
@@ -208,6 +322,8 @@ export class AiVm {
     if (!exe) { this.setStep({ step: 'failed', error: `${tool} isn't installed on this machine` }); return }
     let out = ''
     let shown = ''
+    let sinceCode = null // what the tool printed since a code was typed into it
+    let stale = '' // the link of a code that wasn't taken: never shown again
     const proc = this.login(exe, t.args, { env: t.env })
     this.signing = proc
     this.lastActivity = this.now()
@@ -216,19 +332,44 @@ export class AiVm {
     timer.unref?.()
     proc.onData((d) => {
       out = (out + d).slice(-64 * 1024)
+      if (sinceCode !== null) sinceCode = (sinceCode + d).slice(-16 * 1024)
       const r = readSignIn(tool, out)
       if (r.token) {
         keepToken(this.home, tool, r.token)
         process.env.CLAUDE_CODE_OAUTH_TOKEN = r.token
+        sinceCode = null
       }
+      if (sinceCode !== null && codeRefused(tool, sinceCode)) refused()
       const key = `${r.url}\n${r.code}`
-      if (r.url && key !== shown && this.signIn?.step !== 'waiting') {
+      if (r.url && r.url !== stale && key !== shown && this.signIn?.step !== 'waiting') {
         shown = key
-        this.setStep({ step: r.code ? 'code' : 'link', url: r.url, code: r.code, needsCode: r.needsCode })
+        this.setStep({ step: r.code ? 'code' : 'link', url: r.url, code: r.code, needsCode: r.needsCode, error: this.refusedError || '' })
       }
     })
+    // A code the tool didn't take: its sign-in starts over with a new link (Claude: Enter retries).
+    const refused = () => {
+      if (this.signing !== proc || sinceCode === null) return
+      sinceCode = null
+      clearTimeout(this.codeTimer)
+      this.refusedError = `${tool} didn't take that code. Open the new link and paste the code it gives you.`
+      this.log('sign-in: the code was not taken; starting over')
+      if (t.retry) proc.write(t.retry)
+      // Only what comes after counts: the old link is not shown again, even redrawn.
+      stale = readSignIn(tool, out).url || stale
+      out = ''
+      shown = ''
+      this.setStep({ step: 'starting', error: this.refusedError })
+    }
+    this.codeGiven = () => {
+      sinceCode = ''
+      clearTimeout(this.codeTimer)
+      this.codeTimer = setTimeout(refused, this.codeMs)
+      this.codeTimer.unref?.()
+    }
+    this.refusedError = ''
     proc.exited.then(async (code) => {
       clearTimeout(timer)
+      if (this.signing === proc) clearTimeout(this.codeTimer)
       if (this.signing !== proc) return
       this.signing = null
       this.signedIn = await this.checkSignedIn()
@@ -241,7 +382,8 @@ export class AiVm {
   giveCode (code) {
     if (!this.signing) { this.log('a sign-in code came with no sign-in running'); return }
     this.signing.write(`${code}\r`)
-    this.setStep({ ...(this.signIn || {}), step: 'waiting', needsCode: false })
+    if (this.codeGiven) this.codeGiven()
+    this.setStep({ ...(this.signIn || {}), step: 'waiting', needsCode: false, error: '' })
   }
 
   setStep (step) {
@@ -370,7 +512,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 || '', 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 || '', 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/agent-auth.js

@@ -11,6 +11,7 @@
 import crypto from 'node:crypto'
 import { newToken, hashToken } from './tokens.js'
 import { HttpError } from './http.js'
+import { dayOf, hintOf } from './sandbox-keys.js'
 
 export const ACCESS_TTL_MS = 60 * 60 * 1000
 export const REFRESH_TTL_MS = 30 * 24 * 60 * 60 * 1000
@@ -93,10 +94,13 @@ export function makeAgentAuth ({ store, now, bearer }) {
     return resume(agent)
   }
 
-  /** A new app key (qk_) for an agent: shown once, only its hash is stored. */
-  async function mintAppKey (agentId, name) {
+  /**
+   * A new app key (qk_) for an agent: shown once, only its hash is stored. `sandbox` ({ room,
+   * sessionLink, sessionName, slot }) makes it a sandbox key, which also keeps its last four characters.
+   */
+  async function mintAppKey (agentId, name, sandbox = null) {
     const key = newToken('qk_')
-    const row = await store.createAgentAppKey({ agentId, name, keyHash: hashToken(key) })
+    const row = await store.createAgentAppKey({ agentId, name, keyHash: hashToken(key), ...(sandbox ? { ...sandbox, kind: 'sandbox', hint: hintOf(key) } : {}) })
     return { id: row.id, name: row.name, createdAt: row.createdAt, key }
   }
 
@@ -108,6 +112,8 @@ export function makeAgentAuth ({ store, now, bearer }) {
     const agent = await store.agentById(row.agentId)
     if (!agent || agent.revokedAt) throw new HttpError(401, 'this agent was revoked')
     if (!row.lastUsedAt || now() - row.lastUsedAt >= TOUCH_EVERY_MS) await store.touchAgentAppKey(row.id)
+    // Every request counts toward the key's use that day (the seven-day bars); a lost count never fails one.
+    await store.countAppKeyUse(row.id, dayOf(now())).catch(() => {})
     if (!agent.lastUsedAt || now() - agent.lastUsedAt >= TOUCH_EVERY_MS) await store.touchAgent(agent.id)
     return { agent, keyRow: null, appKey: row }
   }

package/src/api/fly-machines.js

@@ -1,11 +1,19 @@
 // The Fly Machines API, for people's cloud AI machines (routes/ai-vm.js): one machine and one
 // volume per person, in the app AI_VM_APP (never the relay's). Plain fetch, so tests point it
 // at a fake server. See https://fly.io/docs/machines/api/.
+//
+// Spares: machines made ahead of anyone connecting, with their volume, running `quilt ai-vm` as
+// a spare: it reads the AI tools into memory (a tool read cold off the disk takes up to 18 s
+// before it prints anything) and is then suspended, memory and all, which costs only its disk.
+// Connecting relabels one as the person's and resumes it: it is running in a second or two, with
+// every tool ready, and takes its one-time join link from the API.
 
 export const FLY_API = 'https://api.machines.dev/v1'
 // Small enough to suspend (Fly suspends machines of 2 GB or less) and to cost little.
 export const GUEST = { cpu_kind: 'shared', cpus: 2, memory_mb: 2048 }
 export const VOLUME_GB = 5
+export const SPARE = 'ai-vm-spare'
+const OWNED = 'ai-vm'
 const ID = /^[A-Za-z0-9_-]{1,64}$/
 
 const needId = (id, what) => {
@@ -17,10 +25,36 @@ const needId = (id, what) => {
  * A client for one Fly app. `token` is FLY_API_TOKEN; `image` the AI machine image
  * (registry.fly.io/<app>:<tag>); `base` and `fetch` are for tests.
  */
-export function flyMachines ({ token, app, image, region = 'iad', base = FLY_API, fetch: fetchImpl = globalThis.fetch }) {
+export function flyMachines ({ token, app, image, region = 'iad', spares = 0, base = FLY_API, fetch: fetchImpl = globalThis.fetch, retryMs = 1000 }) {
   const root = `${String(base).replace(/\/+$/, '')}/apps/${encodeURIComponent(app)}`
 
-  async function call (method, path, body, { gone = false } = {}) {
+  /**
+   * The image's own command, restarted on a crash. A spare's metadata says so, with the hash of
+   * the key it asks the API for its claim with (`spareHash`).
+   */
+  const config = ({ volumeId, env = {}, spareHash = '' }) => ({
+    image,
+    env,
+    guest: GUEST,
+    mounts: [{ volume: needId(volumeId, 'volume'), path: '/data' }],
+    restart: { policy: 'on-failure', max_retries: 5 },
+    auto_destroy: false,
+    metadata: spareHash ? { quilt: SPARE, quilt_spare: spareHash } : { quilt: OWNED }
+  })
+
+  // Fly lets a few writes through at once, then answers 429 for a moment: those are asked again.
+  async function call (method, path, body, opts = {}) {
+    for (let tries = 1; ; tries++) {
+      try {
+        return await callOnce(method, path, body, opts)
+      } catch (err) {
+        if (err.status !== 429 || tries >= 5) throw err
+        await new Promise((resolve) => setTimeout(resolve, retryMs * tries))
+      }
+    }
+  }
+
+  async function callOnce (method, path, body, { gone = false } = {}) {
     let res
     try {
       res = await fetchImpl(root + path, {
@@ -43,22 +77,42 @@ export function flyMachines ({ token, app, image, region = 'iad', base = FLY_API
     app,
     image,
     region,
+    spares,
     /** A new volume for one person's machine; encrypted, in this app's region. */
     createVolume: async ({ name, sizeGb = VOLUME_GB }) => call('POST', '/volumes', { name, region, size_gb: sizeGb, encrypted: true }),
     /** A machine running the AI image with the volume as /data. It restarts on a crash, never on its own after a stop. */
-    createMachine: async ({ name, volumeId, env = {} }) => call('POST', '/machines', {
-      name,
-      region,
-      config: {
-        image,
-        env,
-        guest: GUEST,
-        mounts: [{ volume: needId(volumeId, 'volume'), path: '/data' }],
-        restart: { policy: 'on-failure', max_retries: 5 },
-        auto_destroy: false,
-        metadata: { quilt: 'ai-vm' }
+    createMachine: async ({ name, volumeId, env = {}, spareHash = '' }) => call('POST', '/machines', { name, region, config: config({ volumeId, env, spareHash }) }),
+    /** The spare machines there are now: { id, volumeId, image, state, hash, region, createdAt }. */
+    listSpares: async () => {
+      const list = await call('GET', `/machines?metadata.quilt=${SPARE}`)
+      return (Array.isArray(list) ? list : [])
+        .filter((m) => m && m.config && m.config.metadata && m.config.metadata.quilt === SPARE && ID.test(String(m.id)))
+        .map((m) => ({
+          id: m.id,
+          volumeId: (m.config.mounts && m.config.mounts[0] && m.config.mounts[0].volume) || '',
+          image: m.config.image || '',
+          state: m.state || '',
+          hash: String(m.config.metadata.quilt_spare || ''),
+          region: m.region || region,
+          createdAt: Date.parse(m.created_at || '') || 0
+        }))
+    },
+    /**
+     * Makes a spare a person's machine and wakes it, as it is: relabelling needs no restart, so
+     * the tools it read stay in memory. A spare still starting up is left to finish.
+     */
+    claimSpare: async (id, { state = '' } = {}) => {
+      // Its key's hash stays in its metadata, unused: the API knows the machine is taken.
+      await call('POST', `/machines/${needId(id, 'machine')}/metadata/quilt`, { value: OWNED })
+      if (state === 'started') return
+      try {
+        await call('POST', `/machines/${needId(id, 'machine')}/start`)
+      } catch (err) {
+        // Not woken: it is a spare again, for the next person.
+        await call('POST', `/machines/${needId(id, 'machine')}/metadata/quilt`, { value: SPARE }).catch(() => {})
+        throw err
       }
-    }),
+    },
     getMachine: async (id) => call('GET', `/machines/${needId(id, 'machine')}`),
     /** Starts a stopped machine, or resumes a suspended one where it was. */
     start: async (id) => call('POST', `/machines/${needId(id, 'machine')}/start`),
@@ -72,5 +126,8 @@ export function flyMachines ({ token, app, image, region = 'iad', base = FLY_API
 /** The client from the API's environment, or null when cloud AI machines aren't set up here. */
 export function flyFromEnv (env = process.env) {
   if (!env.FLY_API_TOKEN || !env.AI_VM_APP || !env.AI_VM_IMAGE) return null
-  return flyMachines({ token: env.FLY_API_TOKEN, app: env.AI_VM_APP, image: env.AI_VM_IMAGE, region: env.AI_VM_REGION || 'iad' })
+  // AI_VM_SPARES: how many spare machines wait ready for the next people to connect (2 unless set:
+  // one is still ready while the one after a connect is being made, which takes a minute or two).
+  const spares = env.AI_VM_SPARES === undefined || env.AI_VM_SPARES === '' ? 2 : Math.max(0, Math.min(20, Math.floor(Number(env.AI_VM_SPARES)) || 0))
+  return flyMachines({ token: env.FLY_API_TOKEN, app: env.AI_VM_APP, image: env.AI_VM_IMAGE, region: env.AI_VM_REGION || 'iad', spares })
 }

package/src/api/memory-store.js

@@ -34,6 +34,7 @@ export function createMemoryStore ({ now = Date.now } = {}) {
   const users = new Map(); const orgs = new Map(); const roles = new Map(); const members = new Map()
   const teams = new Map(); const teamMembers = new Map(); const invites = new Map(); const requests = new Map()
   const agentInvites = new Map(); const keyRows = new Map(); const appKeys = new Map()
+  const appKeyUses = new Map() // "key id\nday" -> requests that day (agent_app_key_uses)
   const events = new Map(); const issues = new Map()
   const relaySessions = new Map(); const visits = new Map(); const seenEvents = new Map(); const actions = new Map()
   const accessTypes = new Map(); const grants = new Map(); const sessionInvites = new Map()
@@ -42,10 +43,16 @@ export function createMemoryStore ({ now = Date.now } = {}) {
   const agentPlacements = new Map(); const workspaceAgentOverrides = new Map()
   const sessionAgentExclusions = new Map(); const agentWebhooks = new Map()
   const aiVms = new Map() // user id -> the person's cloud AI machine (ai_vms)
-  // The relay on many machines (20261017000000_relay_cluster.sql).
+  // The relay on many machines (20261017100000_relay_cluster.sql, 20261018100000_relay_autoscale.sql).
   const relayMachines = new Map(); const relayRooms = new Map(); const relayJobs = new Map()
   const hostedRooms = new Map() // "account\nroom" -> { account, room, addedAt }
   const hostedWebhooks = new Map(); const resumeSignatures = new Map()
+  // Secrets (20261018000000_secrets.sql): only what the vault sealed.
+  const secretRows = new Map(); const secretDataKeys = new Map(); const secretSettingsRows = new Map()
+  const secretTickets = new Map(); const secretRuns = new Map(); const secretAsks = new Map(); const secretUses = []
+  const scopeKey = (scopeType, scopeId) => `${scopeType}\n${scopeId}`
+  // A secret as the API's routes see it: never its sealed value (secretSealed reads that, for the vault).
+  const secretMeta = (r) => { if (!r) return null; const { sealedValue, ...rest } = copy(r); return rest }
   const wmKey = (workspaceId, account) => `${workspaceId}\n${account}`
   const grantKey = (room, account) => `${room}\n${account}`
   const waoKey = (workspaceId, agentId) => `${workspaceId}\n${agentId}`
@@ -236,11 +243,36 @@ export function createMemoryStore ({ now = Date.now } = {}) {
     },
 
     // App keys (qk_): hashes only, and they don't run out.
-    async createAgentAppKey ({ agentId, name, keyHash }) {
+    // A sandbox key (kind 'sandbox') also has its session, slot and hint; a plain app key has none.
+    async createAgentAppKey ({ agentId, name, keyHash, kind = 'app', hint = null, room = null, sessionLink = null, sessionName = null, slot = null }) {
       if (!agents.has(agentId)) throw fkViolation('agent', 'does not exist')
-      const row = { id: uuid(), agentId, name, keyHash, createdAt: now(), lastUsedAt: null, revokedAt: null }
+      if (kind === 'sandbox' && !(room && sessionLink && slot)) throw checkViolation('a sandbox key has a session and a slot')
+      const row = { id: uuid(), agentId, name, keyHash, createdAt: now(), lastUsedAt: null, revokedAt: null, kind, hint, room, sessionLink, sessionName, slot }
       appKeys.set(row.id, row); return copy(row)
     },
+    async agentAppKeyById (id) { return copy(appKeys.get(id)) },
+    // These agents' sandbox keys, revoked ones too (until removed), newest first.
+    async listSandboxKeys (agentIds) {
+      const ids = new Set(agentIds)
+      return all(appKeys, (k) => ids.has(k.agentId) && k.kind === 'sandbox').sort((a, b) => b.createdAt - a.createdAt).map(copy)
+    },
+    // Only a revoked key, and only one of this agent's; its use counts go with it.
+    async removeAgentAppKey (agentId, id) {
+      const k = appKeys.get(id)
+      if (!k || k.agentId !== agentId || !k.revokedAt) return false
+      appKeys.delete(id)
+      for (const u of [...appKeyUses.keys()]) if (u.startsWith(`${id}\n`)) appKeyUses.delete(u)
+      return true
+    },
+    async countAppKeyUse (keyId, day) {
+      if (!appKeys.has(keyId)) throw fkViolation('app key', 'does not exist')
+      const u = `${keyId}\n${day}`
+      appKeyUses.set(u, (appKeyUses.get(u) || 0) + 1)
+    },
+    async appKeyUses (keyIds, sinceDay) {
+      const ids = new Set(keyIds)
+      return [...appKeyUses].map(([u, count]) => { const [keyId, day] = u.split('\n'); return { keyId, day, count } }).filter((r) => ids.has(r.keyId) && r.day >= sinceDay)
+    },
     async agentAppKeyByHash (h) { return copy(all(appKeys, (k) => k.keyHash === h)[0]) },
     async listAgentAppKeys (agentId) {
       return all(appKeys, (k) => k.agentId === agentId && !k.revokedAt).sort((a, b) => a.createdAt - b.createdAt).map(copy)
@@ -359,7 +391,7 @@ export function createMemoryStore ({ now = Date.now } = {}) {
     async relayMachine (id) { return copy(relayMachines.get(id)) },
     async relayMachines () { return [...relayMachines.values()].sort((a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id)).map(copy) },
     async putRelayMachine ({ id, ...fields }) {
-      const cur = relayMachines.get(id) || { id, region: '', capacity: 50, state: 'active', dedicatedRoom: null, load: {}, helloAt: null, reportedAt: null, createdAt: now() }
+      const cur = relayMachines.get(id) || { id, region: '', capacity: 50, state: 'active', dedicatedRoom: null, load: {}, hotAt: null, overAt: null, emptyAt: null, helloAt: null, reportedAt: null, createdAt: now() }
       for (const [k, v] of Object.entries(fields)) if (v !== undefined) cur[k] = structuredClone(v)
       if (cur.dedicatedRoom) for (const m of relayMachines.values()) if (m.id !== id && m.dedicatedRoom === cur.dedicatedRoom) throw Object.assign(new Error('duplicate key value violates unique constraint relay_machines_dedicated_room_key'), { code: '23505' })
       relayMachines.set(id, cur)
@@ -375,7 +407,7 @@ export function createMemoryStore ({ now = Date.now } = {}) {
     // Mirrors place_relay_room: placed once; the room stays where it was put.
     async placeRelayRoom (room, machineId) {
       if (!relayMachines.has(machineId)) throw fkViolation('relay machine', 'does not exist')
-      if (!relayRooms.has(room)) relayRooms.set(room, { room, machineId, state: 'placed', stats: {}, busyMinutes: 0, heavy: [], placedAt: now(), reportedAt: null })
+      if (!relayRooms.has(room)) relayRooms.set(room, { room, machineId, state: 'placed', stats: {}, busyMinutes: 0, heavy: [], placedAt: now(), reportedAt: null, movedAt: null })
       return copy(relayRooms.get(room))
     },
     async setRelayRoom (room, patch) {
@@ -981,7 +1013,7 @@ export function createMemoryStore ({ now = Date.now } = {}) {
     async createAiVm ({ userId, tool, model = '', prompt = '', cap = 0, region = '' }) {
       if (!profiles.has(userId)) throw fkViolation('person', 'does not exist')
       if (aiVms.has(userId)) throw duplicate('cloud AI machine')
-      const row = { userId, tool, model, prompt, cap, agentId: null, inviteId: null, machineId: null, volumeId: null, region, state: 'creating', error: '', signedIn: false, usageToday: {}, lastReportAt: null, createdAt: now(), updatedAt: now() }
+      const row = { userId, tool, model, prompt, cap, agentId: null, inviteId: null, machineId: null, volumeId: null, region, state: 'creating', error: '', signedIn: false, usageToday: {}, sessions: [], lastReportAt: null, createdAt: now(), updatedAt: now() }
       aiVms.set(userId, row); return copy(row)
     },
     async aiVmOf (userId) { return copy(aiVms.get(userId)) },
@@ -1075,6 +1107,110 @@ export function createMemoryStore ({ now = Date.now } = {}) {
       return copy(f)
     },
 
+    // Secrets (see 20261018000000_secrets.sql).
+    async listSecrets (scopeType, scopeId) { return all(secretRows, (r) => r.scopeType === scopeType && r.scopeId === scopeId).sort((a, b) => a.name.localeCompare(b.name)).map(secretMeta) },
+    async secretByName (scopeType, scopeId, name) { return secretMeta(all(secretRows, (r) => r.scopeType === scopeType && r.scopeId === scopeId && r.name === name)[0]) },
+    async secretById (id) { return secretMeta(secretRows.get(id)) },
+    async secretSealed (id) { const r = secretRows.get(id); return r ? { sealedValue: r.sealedValue, keyVersion: r.keyVersion } : null },
+    async putSecret ({ scopeType, scopeId, name, sealedValue, keyVersion, digest, upstream, format, who, by }) {
+      if (!secretDataKeys.has(`${scopeKey(scopeType, scopeId)}\n${keyVersion}`)) throw fkViolation('that data key', 'does not exist')
+      const had = all(secretRows, (r) => r.scopeType === scopeType && r.scopeId === scopeId && r.name === name)[0]
+      const at = now()
+      if (had) { Object.assign(had, { sealedValue, keyVersion, digest, upstream, format: copy(format), who, updatedBy: by, updatedAt: at }); return secretMeta(had) }
+      const row = { id: uuid(), scopeType, scopeId, name, sealedValue, keyVersion, digest, upstream, format: copy(format), who, createdBy: by, updatedBy: by, createdAt: at, updatedAt: at, lastUsedAt: null }
+      secretRows.set(row.id, row)
+      return secretMeta(row)
+    },
+    async updateSecret (id, { who, updatedBy }) {
+      const r = secretRows.get(id)
+      if (!r) return null
+      Object.assign(r, { who, updatedBy, updatedAt: now() })
+      return secretMeta(r)
+    },
+    async deleteSecret (id) {
+      for (const [k, a] of secretAsks) if (a.secretId === id) secretAsks.delete(k)
+      for (let i = secretUses.length - 1; i >= 0; i--) if (secretUses[i].secretId === id) secretUses.splice(i, 1)
+      return secretRows.delete(id)
+    },
+    async deleteScopeSecrets (scopeType, scopeId) {
+      for (const r of all(secretRows, (x) => x.scopeType === scopeType && x.scopeId === scopeId)) await this.deleteSecret(r.id)
+      for (const k of [...secretDataKeys.keys()]) if (k.startsWith(`${scopeKey(scopeType, scopeId)}\n`)) secretDataKeys.delete(k)
+      secretSettingsRows.delete(scopeKey(scopeType, scopeId))
+    },
+    async secretDataKey (scopeType, scopeId) {
+      return copy(all(secretDataKeys, (k) => k.scopeType === scopeType && k.scopeId === scopeId).sort((a, b) => b.version - a.version)[0] || null)
+    },
+    async secretDataKeyVersion (scopeType, scopeId, version) { return copy(secretDataKeys.get(`${scopeKey(scopeType, scopeId)}\n${version}`) || null) },
+    /** Stores a data key unless that version is already there; answers the one stored. */
+    async putSecretDataKey ({ scopeType, scopeId, version, sealedKey, provider }) {
+      const k = `${scopeKey(scopeType, scopeId)}\n${version}`
+      if (!secretDataKeys.has(k)) secretDataKeys.set(k, { scopeType, scopeId, version, sealedKey, provider, createdAt: now() })
+      return copy(secretDataKeys.get(k))
+    },
+    async secretSettings (scopeType, scopeId) {
+      return copy(secretSettingsRows.get(scopeKey(scopeType, scopeId))) || { scopeType, scopeId, inheritOff: false, inheritOffBy: null, inheritOffAt: null, agentsOn: false, agents: 'all', updatedAt: null }
+    },
+    async putSecretSettings (scopeType, scopeId, patch) {
+      const row = { ...(await this.secretSettings(scopeType, scopeId)), ...patch, scopeType, scopeId, updatedAt: now() }
+      secretSettingsRows.set(scopeKey(scopeType, scopeId), copy(row))
+      return copy(row)
+    },
+    async createSecretTicket ({ tokenHash, scopeType, scopeId, entries, createdBy, expiresAt }) {
+      const t = { id: uuid(), tokenHash, scopeType, scopeId, entries: copy(entries), createdBy, createdAt: now(), expiresAt, redeemedAt: null, storedAt: null }
+      secretTickets.set(t.id, t)
+      return copy(t)
+    },
+    async redeemSecretTicket (tokenHash, at) {
+      const t = all(secretTickets, (x) => x.tokenHash === tokenHash)[0]
+      if (!t || t.redeemedAt || t.expiresAt <= at) return null
+      t.redeemedAt = at
+      return copy(t)
+    },
+    async secretTicketById (id) { return copy(secretTickets.get(id)) },
+    async markSecretTicketStored (id, at) {
+      const t = secretTickets.get(id)
+      if (!t || !t.redeemedAt || t.storedAt) return false
+      t.storedAt = at
+      return true
+    },
+    async pruneSecretTickets (before) { for (const [k, t] of secretTickets) if (t.expiresAt < before) secretTickets.delete(k) },
+    async createSecretRun ({ tokenHash, room, account, kind, label = '', expiresAt }) {
+      const r = { id: uuid(), tokenHash, room, account, kind, label, createdAt: now(), expiresAt, revokedAt: null }
+      secretRuns.set(r.id, r)
+      return copy(r)
+    },
+    async secretRunByToken (tokenHash) { return copy(all(secretRuns, (r) => r.tokenHash === tokenHash)[0]) },
+    async secretRunById (id) { return copy(secretRuns.get(id)) },
+    async revokeSecretRun (id, at) { const r = secretRuns.get(id); if (!r || r.revokedAt) return false; r.revokedAt = at; return true },
+    async putSecretRunAsks (runId, asks) {
+      for (const a of asks) secretAsks.set(`${runId}\n${a.secretId}`, { runId, secretId: a.secretId, name: a.name, state: a.state || 'asked', askedAt: now(), answeredAt: null })
+    },
+    async listSecretRunAsks (runId) { return all(secretAsks, (a) => a.runId === runId).map(copy) },
+    async answerSecretRunAsks (runId, state, at) {
+      let n = 0
+      for (const a of secretAsks.values()) if (a.runId === runId && a.state === 'asked') { Object.assign(a, { state, answeredAt: at }); n++ }
+      return n
+    },
+    /** A person's runs still waiting for them to allow people-only secrets: [{ run, asks }]. */
+    async pendingSecretAsks (account, at) {
+      const out = []
+      for (const r of secretRuns.values()) {
+        if (r.account !== account || r.revokedAt || r.expiresAt <= at) continue
+        const asks = all(secretAsks, (a) => a.runId === r.id && a.state === 'asked').map(copy)
+        if (asks.length) out.push({ run: copy(r), asks })
+      }
+      return out.sort((a, b) => a.run.createdAt - b.run.createdAt)
+    },
+    async recordSecretUse ({ secretId, runId, room, account, upstream, at }) {
+      const r = secretRows.get(secretId)
+      if (!r) return
+      r.lastUsedAt = at
+      secretUses.push({ id: secretUses.length + 1, secretId, runId, room, account, upstream, at })
+    },
+    async listSecretUses (secretIds, { limit = 100 } = {}) {
+      return secretUses.filter((u) => secretIds.includes(u.secretId)).sort((a, b) => b.at - a.at).slice(0, limit).map(copy)
+    },
+
     // Test-only views (production reads the tables in the Supabase dashboard).
     listEvents () { return [...events.values()].map(copy) },
     listIssues () { return [...issues.values()].map(copy) },