heyquilt 0.3.90 → 0.3.107

package/src/api/server.js

@@ -27,6 +27,7 @@ import { relayCluster } from './relay-cluster.js'
 import crypto from 'node:crypto'
 import { githubRoutes } from './routes/github.js'
 import { githubApp, ensureWebhookSecret, redeliverFailed } from './github-app.js'
+import { releaseSource } from './releases.js'
 import { sessionRoutes } from './routes/sessions.js'
 import { accessTypeRoutes } from './routes/access-types.js'
 import { grantRoutes } from './routes/grants.js'
@@ -43,6 +44,7 @@ import { aiVmRoutes, cloudAiOf, WAIT_MS as AI_VM_WAIT_MS } from './routes/ai-vm.
 import { personaName } from '../persona.js'
 import { CLOUD_LABEL } from '../cloud-ai.js'
 import { routeName, cleanEvent } from './issues.js'
+import { secretRoutes } from './routes/secrets.js'
 
 const API_VERSION = JSON.parse(fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json'), 'utf8')).version
 
@@ -64,7 +66,7 @@ const MCP_TIMEOUT_MS = 30 * 1000
 // a change to its grant reaches it as soon as it reaches a connected app.
 const PASS_REUSE_MARGIN_MS = 5 * 60 * 1000
 
-export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, siteUrl, apiUrl = 'https://api.heyquilt.com', mailer = { send: async () => { throw new Error('no mailer configured') } }, now = Date.now, log = () => {}, startLimit = 10, inviteLimit = 10, inviteSendLimit = 20, tokenLimit = 30, joinLimit = 20, trustProxy = false, maxStartKeys = 10_000, passKey = '', passLimit = 60, relayUrl = HOSTED_RELAY, mcpLimit = 600, reportKey = '', reportLimit = 10, slowMs = 2000, pruneEveryMs = 60 * 60 * 1000, keepEventsMs = 30 * 24 * 60 * 60 * 1000, keepIssuesMs = 90 * 24 * 60 * 60 * 1000, pruneStartMs = 10_000, relaySecret = '', workspaces = false, fileStore = null, maxFileBytes = 500 * 1024 * 1024, workspaceQuotaBytes = 5 * 1024 * 1024 * 1024, maxWorkspaceFiles = 2000, webhookFetch = globalThis.fetch, webhookLookup, allowLocalWebhooks = false, github = null, githubFetch = globalThis.fetch, fly = null, aiVmWaitMs = AI_VM_WAIT_MS, relayFetch = null, relayFly = null, heavy = null, clusterTiming = {} }) {
+export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, siteUrl, apiUrl = 'https://api.heyquilt.com', mailer = { send: async () => { throw new Error('no mailer configured') } }, now = Date.now, log = () => {}, startLimit = 10, inviteLimit = 10, inviteSendLimit = 20, tokenLimit = 30, joinLimit = 20, trustProxy = false, maxStartKeys = 10_000, passKey = '', passLimit = 60, relayUrl = HOSTED_RELAY, mcpLimit = 600, reportKey = '', reportLimit = 10, slowMs = 2000, pruneEveryMs = 60 * 60 * 1000, keepEventsMs = 30 * 24 * 60 * 60 * 1000, keepIssuesMs = 90 * 24 * 60 * 60 * 1000, pruneStartMs = 10_000, relaySecret = '', workspaces = false, fileStore = null, maxFileBytes = 500 * 1024 * 1024, workspaceQuotaBytes = 5 * 1024 * 1024 * 1024, maxWorkspaceFiles = 2000, webhookFetch = globalThis.fetch, webhookLookup, allowLocalWebhooks = false, github = null, githubFetch = globalThis.fetch, fly = null, aiVmWaitMs = AI_VM_WAIT_MS, aiVmSpareSuspendMs, relayFetch = null, relayFly = null, heavy = null, relayTargets = null, clusterTiming = {}, vaultSecret = '', vaultUrl = 'https://vault.heyquilt.com', allowLocalUpstreams = false, secretWaitMs }) {
   // PASS_SIGNING_KEY. A bad one should stop the API at start, not fail every pass later.
   if (passKey) passPublicKey(passKey)
   const site = String(siteUrl || '').replace(/\/+$/, '')
@@ -213,7 +215,7 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
     ['GET', /^\/healthz$/, async () => ({ ok: true })],
 
     // Which optional parts this API has on, for the app and the MCPs to decide what to show. Public.
-    ['GET', /^\/v1\/features$/, async () => ({ workspaces: !!workspaces })],
+    ['GET', /^\/v1\/features$/, async () => ({ workspaces: !!workspaces, secrets: !!vaultSecret })],
 
     ['POST', /^\/v1\/device\/start$/, async (req, body) => {
       limitStarts(req)
@@ -346,7 +348,7 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
   const deliveries = new Set()
   const trackDelivery = (p) => { deliveries.add(p); p.finally(() => deliveries.delete(p)).catch(() => {}); return p }
   // The relay on many machines: where each room lives, and heavy rooms' own machines (relay-cluster.js).
-  const cluster = relayCluster({ store, relayUrl: relay, relaySecret, fetch: relayFetch || githubFetch, now, log, fly: relayFly, ...(heavy ? { limits: heavy } : {}), ...clusterTiming })
+  const cluster = relayCluster({ store, relayUrl: relay, relaySecret, fetch: relayFetch || githubFetch, now, log, fly: relayFly, ...(heavy ? { limits: heavy } : {}), ...(relayTargets ? { targets: relayTargets } : {}), ...clusterTiming })
   const ctx = { store, user, person, device, bearer, now, site, apiUrl: api, mailer, log, limit: limitInvites, limitSend: limitInviteSend, limitTokens, limitStarts, spendResume, resumeWindowMs: RESUME_WINDOW_MS, limitJoin, agentAuth, reportKey, limitReports, relaySecret, files, maxFileBytes, workspaceQuotaBytes, maxWorkspaceFiles }
   // GitHub's webhook secret: set on the app by this API at start (github-app.js), kept in the store when the environment gives none.
   const hookSecret = { value: (github && github.webhookSecret) || '' }
@@ -357,20 +359,23 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
     await redeliverFailed({ app, log })
   })().catch((err) => log(`github at start: ${err.message}`))
   // A person's AI on its own cloud machine (routes/ai-vm.js): off (503) without Fly set up.
-  const aiVm = aiVmRoutes({ ...ctx, relayUrl, fly, waitMs: aiVmWaitMs })
+  const aiVm = aiVmRoutes({ ...ctx, relayUrl, fly, waitMs: aiVmWaitMs, spareSuspendMs: aiVmSpareSuspendMs })
   routes.push(...aiVm.routes)
   // A team's git rule or who is on a team changed: the relay asks its sessions' rules again now (relay /github/policy).
-  const policyChanged = () => {
+  // With a room (a session put in or taken out of a workspace), only that session asks.
+  const policyChanged = (room = '') => {
     if (!relay || !relaySecret) return
-    cluster.tellRelays('/github/policy', {}).catch((err) => log(`git rules to relay: ${err.message}`))
+    cluster.tellRelays('/github/policy', room ? { room } : {}).catch((err) => log(`git rules to relay: ${err.message}`))
   }
-  routes.push(...orgRoutes(ctx), ...memberRoutes(ctx), ...teamRoutes({ ...ctx, policyChanged }), ...inviteRoutes(ctx), ...agentRoutes(ctx), ...agentInviteRoutes({ ...ctx, workspaces }), ...joinRoutes(ctx), ...relayRoutes(ctx), ...githubRoutes({ ...ctx, github, githubFetch, relayHttp: relay, relayFetch: githubFetch, tellRelays: (path, body) => cluster.tellRelays(path, body), hookSecret, workspaces }), ...relayClusterRoutes({ ...ctx, cluster }), ...sessionRoutes(ctx), ...accessTypeRoutes(ctx), ...grantRoutes({ ...ctx, workspaces }), ...sessionInviteRoutes({ ...ctx, workspaces }), ...issueRoutes(ctx))
+  routes.push(...orgRoutes(ctx), ...memberRoutes(ctx), ...teamRoutes({ ...ctx, policyChanged }), ...inviteRoutes(ctx), ...agentRoutes({ ...ctx, passKey }), ...agentInviteRoutes({ ...ctx, workspaces }), ...joinRoutes(ctx), ...relayRoutes(ctx), ...githubRoutes({ ...ctx, github, githubFetch, relayHttp: relay, relayFetch: githubFetch, tellRelays: (path, body) => cluster.tellRelays(path, body), hookSecret, workspaces }), ...relayClusterRoutes({ ...ctx, cluster }), ...sessionRoutes(ctx), ...accessTypeRoutes(ctx), ...grantRoutes({ ...ctx, workspaces }), ...sessionInviteRoutes({ ...ctx, workspaces }), ...issueRoutes(ctx))
   // Always routed: with the flag off each answers a plain 404 of its own, so the app's
   // check at every launch isn't filed as a missing route.
   // Only these take a hosted agent's pass (workspaceReach), so they alone get the pass key.
-  routes.push(...workspaceRoutes({ ...ctx, workspaces, passKey }), ...workspaceInviteRoutes({ ...ctx, workspaces, passKey }), ...workspaceAgentRoutes({ ...ctx, workspaces, passKey, relayUrl, webhookFetch, webhookLookup, allowLocalWebhooks, trackDelivery, limitAnnounce }))
+  routes.push(...workspaceRoutes({ ...ctx, workspaces, passKey, policyChanged }), ...workspaceInviteRoutes({ ...ctx, workspaces, passKey }), ...workspaceAgentRoutes({ ...ctx, workspaces, passKey, relayUrl, webhookFetch, webhookLookup, allowLocalWebhooks, trackDelivery, limitAnnounce }))
   const wsFiles = workspaceFileRoutes({ ...ctx, workspaces, passKey })
   routes.push(...wsFiles.routes)
+  // Secrets (routes/secrets.js): off until the vault is set up (QUILT_VAULT_SECRET).
+  routes.push(...secretRoutes({ ...ctx, passKey, vaultSecret, vaultUrl, allowLocalUpstreams, ...(secretWaitMs ? { waitMs: secretWaitMs } : {}) }))
 
   async function openLink (code) {
     const userCode = normalizeUserCode(code)
@@ -427,6 +432,7 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
     try {
       if (pathname.startsWith('/v1/file-data/') && files instanceof DiskStore) return await serveFileData(req, res, send, pathname.slice('/v1/file-data/'.length))
       if (pathname === '/mcp') return await proxyMcp(req, res, send)
+      if (req.method === 'GET' && (pathname === '/v1/releases/latest' || pathname.startsWith('/v1/download/'))) return await serveRelease(req, res, send, pathname)
       const url = new URL(req.url, 'http://x')
       const route = routes.find(([m, re]) => m === req.method && re.test(url.pathname))
       if (!route) throw Object.assign(new HttpError(404, 'not found'), { noRoute: true })
@@ -452,6 +458,29 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
     }
   })
 
+  // Downloads and the update check (releases.js): public, from the private repository's latest
+  // release, read as Quilt's GitHub App. A download is a redirect to GitHub's own short-lived link.
+  const releases = releaseSource({ github, fetch: githubFetch, now, apiUrl: api })
+  async function serveRelease (req, res, send, pathname) {
+    if (!releases) throw new HttpError(503, 'downloads are not set up on this server')
+    try {
+      if (pathname === '/v1/releases/latest') {
+        const body = JSON.stringify(await releases.latestPublic())
+        res.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'public, max-age=60', ...cors(req) })
+        return res.end(body)
+      }
+      let rest = ''
+      try { rest = decodeURIComponent(pathname.slice('/v1/download/'.length)) } catch {}
+      const [first, second] = rest.split('/')
+      const to = second !== undefined ? await releases.downloadUrl(second, first) : await releases.downloadUrl(first)
+      res.writeHead(302, { location: to, 'cache-control': 'no-store', ...cors(req) })
+      return res.end()
+    } catch (err) {
+      if (err && err.status && !(err instanceof HttpError)) throw new HttpError(err.status, err.message)
+      throw err
+    }
+  }
+
   // Hosted agents' MCP: the agent's access key signs it in here; the relay gets the same
   // request with a pass for the agent, and its answer comes straight back. Stateless on
   // both sides, so each request stands alone. The pass is for the room the agent is joining
@@ -573,6 +602,8 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
     // Workspace files: uploads that never landed, and deleted files past their 30 days
     // (only with the flag on: before then the tables may not exist yet).
     if (workspaces) try { await wsFiles.sweep() } catch (err) { log(`file sweep failed: ${err?.message || err}`) }
+    // Secrets' write tickets a day past their end (only with secrets on: the tables exist then).
+    if (vaultSecret) try { await store.pruneSecretTickets(now() - 24 * 60 * 60 * 1000) } catch (err) { log(`secret ticket prune failed: ${err?.message || err}`) }
   }
   const prune = setInterval(() => { pruneNow() }, pruneEveryMs)
   prune.unref()
@@ -587,7 +618,7 @@ export function startApi ({ port = 0, host = '127.0.0.1', store, verifyUser, sit
 
   return new Promise((resolve) => server.listen(port, host, () => {
     const p = server.address().port
-    resolve({ port: p, url: `http://${host}:${p}`, cluster, close: () => { clearInterval(prune); clearTimeout(firstPrune); return new Promise((r) => server.close(r)) }, startKeys: () => limitStarts.size(), sweepFiles: (at) => wsFiles.sweep(at), flushWebhooks, githubReady })
+    resolve({ port: p, url: `http://${host}:${p}`, cluster, fillSpares: aiVm.fillSpares, close: () => { clearInterval(prune); clearTimeout(firstPrune); aiVm.close(); return new Promise((r) => server.close(r)) }, startKeys: () => limitStarts.size(), sweepFiles: (at) => wsFiles.sweep(at), flushWebhooks, githubReady })
   }))
 }
 

package/src/api/supabase-store.js

@@ -23,7 +23,7 @@ const TEAM_MEMBER = 'team_id, member_id, access, scopes, added_at'
 const INVITE = 'id, org_id, email, role_id, token_hash, invited_by, expires_at, accepted_at, cancelled_at, created_at'
 const REQUEST = 'id, org_id, user_id, email, status, decided_by, decided_at, created_at'
 const AGENT_INVITE = 'id, token_hash, owner_user_id, org_id, created_by, role_id, teams, expires_at, used_at, used_by_agent_id, rejoined, cancelled_at, created_at, workspace_id, workspace_access, workspace_sessions, global'
-const AGENT_APP_KEY = 'id, agent_id, name, key_hash, created_at, last_used_at, revoked_at'
+const AGENT_APP_KEY = 'id, agent_id, name, key_hash, created_at, last_used_at, revoked_at, kind, hint, room, session_link, session_name, slot'
 const AGENT_KEY = 'id, agent_id, family_id, access_hash, refresh_hash, access_expires_at, refresh_expires_at, refreshed_at, revoked_at, created_at'
 const RELAY_SESSION = 'room, name, owner_account, created_at, last_active_at, renamed_at, workspace_id, workspace_linked_by'
 const ACCESS_TYPE = 'id, owner_account, name, files, folders, talk, created_at, updated_at'
@@ -38,10 +38,18 @@ const AGENT_PLACEMENT = 'agent_id, reach, workspace_ids, sessions, access, scope
 const WORKSPACE_AGENT_OVERRIDE = 'workspace_id, agent_id, sessions, excluded'
 const SESSION_AGENT_EXCLUSION = 'room, agent_id, excluded_by, created_at'
 const AGENT_WEBHOOK = 'agent_id, url, secret, created_at, updated_at'
-const AI_VM = 'user_id, tool, model, prompt, cap, agent_id, invite_id, machine_id, volume_id, region, state, error, signed_in, usage_today, last_report_at, created_at, updated_at'
-const RELAY_MACHINE = 'id, region, capacity, state, dedicated_room, load, hello_at, reported_at, created_at'
-const RELAY_ROOM = 'room, machine_id, state, stats, busy_minutes, heavy, placed_at, reported_at'
+const AI_VM = 'user_id, tool, model, prompt, cap, agent_id, invite_id, machine_id, volume_id, region, state, error, signed_in, usage_today, sessions, last_report_at, created_at, updated_at'
+const RELAY_MACHINE = 'id, region, capacity, state, dedicated_room, load, hot_at, over_at, empty_at, hello_at, reported_at, created_at'
+const RELAY_ROOM = 'room, machine_id, state, stats, busy_minutes, heavy, placed_at, reported_at, moved_at'
 const RELAY_JOB = 'key, state, detail, started_at, finished_at'
+// Secrets: named columns, so a list never carries a sealed value (secretSealed reads that, for the vault).
+const SECRET = 'id, scope_type, scope_id, name, key_version, digest, upstream, format, who, created_by, updated_by, created_at, updated_at, last_used_at'
+const SECRET_DATA_KEY = 'scope_type, scope_id, version, provider, sealed_key, created_at'
+const SECRET_SETTINGS = 'scope_type, scope_id, inherit_off, inherit_off_by, inherit_off_at, agents_on, agents, updated_at'
+const SECRET_TICKET = 'id, token_hash, scope_type, scope_id, entries, created_by, created_at, expires_at, redeemed_at, stored_at'
+const SECRET_RUN = 'id, token_hash, room, account, kind, label, created_at, expires_at, revoked_at'
+const SECRET_ASK = 'run_id, secret_id, name, state, asked_at, answered_at'
+const SECRET_USE = 'id, secret_id, run_id, room, account, upstream, at'
 // PostgREST hands back at most 1000 rows per request: longer lists are read a page at a time.
 const PAGE = 1000
 
@@ -168,8 +176,26 @@ export function createSupabaseStore ({ url, serviceKey, client }) {
     },
 
     // App keys (qk_): hashes only, and they don't run out.
-    async createAgentAppKey ({ agentId, name, keyHash }) {
-      return rowFrom(await one(db.from('agent_app_keys').insert({ agent_id: agentId, name, key_hash: keyHash }).select(AGENT_APP_KEY).single()))
+    // A sandbox key (kind 'sandbox') also has its session, slot and hint; a plain app key has none.
+    async createAgentAppKey ({ agentId, name, keyHash, kind, hint, room, sessionLink, sessionName, slot }) {
+      const insert = { agent_id: agentId, name, key_hash: keyHash, ...toSnake({ kind, hint, room, sessionLink, sessionName, slot }) }
+      return rowFrom(await one(db.from('agent_app_keys').insert(insert).select(AGENT_APP_KEY).single()))
+    },
+    async agentAppKeyById (id) { return rowFrom(await one(db.from('agent_app_keys').select(AGENT_APP_KEY).eq('id', id).maybeSingle())) },
+    // These agents' sandbox keys, revoked ones too (until removed), newest first.
+    async listSandboxKeys (agentIds) {
+      if (!agentIds.length) return []
+      return (await one(db.from('agent_app_keys').select(AGENT_APP_KEY).in('agent_id', agentIds).eq('kind', 'sandbox').order('created_at', { ascending: false }))).map(rowFrom)
+    },
+    // Only a revoked key, and only one of this agent's.
+    async removeAgentAppKey (agentId, id) {
+      const rows = await one(db.from('agent_app_keys').delete().eq('id', id).eq('agent_id', agentId).not('revoked_at', 'is', null).select('id'))
+      return rows.length > 0
+    },
+    async countAppKeyUse (keyId, day) { await one(db.rpc('count_app_key_use', { p_key: keyId, p_day: day })) },
+    async appKeyUses (keyIds, sinceDay) {
+      if (!keyIds.length) return []
+      return (await one(db.from('agent_app_key_uses').select('key_id, day, count').in('key_id', keyIds).gte('day', sinceDay))).map((r) => ({ keyId: r.key_id, day: r.day, count: r.count }))
     },
     async agentAppKeyByHash (h) { return rowFrom(await one(db.from('agent_app_keys').select(AGENT_APP_KEY).eq('key_hash', h).maybeSingle())) },
     async listAgentAppKeys (agentId) {
@@ -279,11 +305,11 @@ export function createSupabaseStore ({ url, serviceKey, client }) {
       return r ? r.value : String(value)
     },
 
-    // Relay machines and where each room lives (20261017000000_relay_cluster.sql; src/api/relay-cluster.js).
+    // Relay machines and where each room lives (20261017100000_relay_cluster.sql, 20261018100000_relay_autoscale.sql; src/api/relay-cluster.js).
     async relayMachine (id) { return rowFrom(await one(db.from('relay_machines').select(RELAY_MACHINE).eq('id', id).maybeSingle())) },
     async relayMachines () { return (await one(db.from('relay_machines').select(RELAY_MACHINE).order('created_at').order('id'))).map(rowFrom) },
-    async putRelayMachine ({ id, helloAt, reportedAt, ...fields }) {
-      const row = toSnake({ id, ...fields, hello_at: ts(helloAt), reported_at: ts(reportedAt) })
+    async putRelayMachine ({ id, helloAt, reportedAt, hotAt, overAt, emptyAt, ...fields }) {
+      const row = toSnake({ id, ...fields, hello_at: ts(helloAt), reported_at: ts(reportedAt), hot_at: ts(hotAt), over_at: ts(overAt), empty_at: ts(emptyAt) })
       return rowFrom(await one(db.from('relay_machines').upsert(row, { onConflict: 'id' }).select(RELAY_MACHINE).single()))
     },
     async relayRoom (room) { return rowFrom(await one(db.from('relay_rooms').select(RELAY_ROOM).eq('room', room).maybeSingle())) },
@@ -294,8 +320,8 @@ export function createSupabaseStore ({ url, serviceKey, client }) {
       return out
     },
     async placeRelayRoom (room, machineId) { return rowFrom((await one(db.rpc('place_relay_room', { p_room: room, p_machine: machineId })))[0]) },
-    async setRelayRoom (room, { reportedAt, ...patch }) {
-      return rowFrom(await one(db.from('relay_rooms').update(toSnake({ ...patch, reported_at: ts(reportedAt) })).eq('room', room).select(RELAY_ROOM).maybeSingle()))
+    async setRelayRoom (room, { reportedAt, movedAt, ...patch }) {
+      return rowFrom(await one(db.from('relay_rooms').update(toSnake({ ...patch, reported_at: ts(reportedAt), moved_at: ts(movedAt) })).eq('room', room).select(RELAY_ROOM).maybeSingle()))
     },
     async forgetRelayRoom (room, machineId) {
       let q = db.from('relay_rooms').delete().eq('room', room)
@@ -760,6 +786,90 @@ export function createSupabaseStore ({ url, serviceKey, client }) {
     async pruneIssues (before) {
       await one(db.from('issues').delete().lt('last_seen_at', ts(before)))
       return 0
+    },
+
+    // Secrets (see 20261018000000_secrets.sql).
+    async listSecrets (scopeType, scopeId) { return (await one(db.from('secrets').select(SECRET).eq('scope_type', scopeType).eq('scope_id', scopeId).order('name'))).map(rowFrom) },
+    async secretByName (scopeType, scopeId, name) { return rowFrom(await one(db.from('secrets').select(SECRET).eq('scope_type', scopeType).eq('scope_id', scopeId).eq('name', name).maybeSingle())) },
+    async secretById (id) { return rowFrom(await one(db.from('secrets').select(SECRET).eq('id', id).maybeSingle())) },
+    async secretSealed (id) {
+      const r = await one(db.from('secrets').select('sealed_value, key_version').eq('id', id).maybeSingle())
+      return r ? { sealedValue: r.sealed_value, keyVersion: r.key_version } : null
+    },
+    async putSecret ({ scopeType, scopeId, name, sealedValue, keyVersion, digest, upstream, format, who, by }) {
+      const set = { sealed_value: sealedValue, key_version: keyVersion, digest, upstream, format, who, updated_by: by, updated_at: new Date().toISOString() }
+      const had = await one(db.from('secrets').update(set).eq('scope_type', scopeType).eq('scope_id', scopeId).eq('name', name).select(SECRET))
+      if (had.length) return rowFrom(had[0])
+      return rowFrom(await one(db.from('secrets').insert({ scope_type: scopeType, scope_id: scopeId, name, ...set, created_by: by }).select(SECRET).single()))
+    },
+    async updateSecret (id, { who, updatedBy }) {
+      return rowFrom(await one(db.from('secrets').update({ who, updated_by: updatedBy, updated_at: new Date().toISOString() }).eq('id', id).select(SECRET).maybeSingle()))
+    },
+    async deleteSecret (id) { return (await one(db.from('secrets').delete().eq('id', id).select('id'))).length > 0 },
+    async deleteScopeSecrets (scopeType, scopeId) {
+      await one(db.from('secrets').delete().eq('scope_type', scopeType).eq('scope_id', scopeId))
+      await one(db.from('secret_data_keys').delete().eq('scope_type', scopeType).eq('scope_id', scopeId))
+      await one(db.from('secret_scope_settings').delete().eq('scope_type', scopeType).eq('scope_id', scopeId))
+    },
+    async secretDataKey (scopeType, scopeId) {
+      return rowFrom(await one(db.from('secret_data_keys').select(SECRET_DATA_KEY).eq('scope_type', scopeType).eq('scope_id', scopeId).order('version', { ascending: false }).limit(1).maybeSingle()))
+    },
+    async secretDataKeyVersion (scopeType, scopeId, version) {
+      return rowFrom(await one(db.from('secret_data_keys').select(SECRET_DATA_KEY).eq('scope_type', scopeType).eq('scope_id', scopeId).eq('version', version).maybeSingle()))
+    },
+    async putSecretDataKey ({ scopeType, scopeId, version, sealedKey, provider }) {
+      await one(db.from('secret_data_keys').upsert({ scope_type: scopeType, scope_id: scopeId, version, sealed_key: sealedKey, provider }, { onConflict: 'scope_type,scope_id,version', ignoreDuplicates: true }))
+      return rowFrom(await one(db.from('secret_data_keys').select(SECRET_DATA_KEY).eq('scope_type', scopeType).eq('scope_id', scopeId).eq('version', version).single()))
+    },
+    async secretSettings (scopeType, scopeId) {
+      const r = rowFrom(await one(db.from('secret_scope_settings').select(SECRET_SETTINGS).eq('scope_type', scopeType).eq('scope_id', scopeId).maybeSingle()))
+      return r || { scopeType, scopeId, inheritOff: false, inheritOffBy: null, inheritOffAt: null, agentsOn: false, agents: 'all', updatedAt: null }
+    },
+    async putSecretSettings (scopeType, scopeId, patch) {
+      const set = toSnake({ ...patch, inheritOffAt: ts(patch.inheritOffAt) })
+      return rowFrom(await one(db.from('secret_scope_settings').upsert({ scope_type: scopeType, scope_id: scopeId, ...set, updated_at: new Date().toISOString() }, { onConflict: 'scope_type,scope_id' }).select(SECRET_SETTINGS).single()))
+    },
+    async createSecretTicket ({ tokenHash, scopeType, scopeId, entries, createdBy, expiresAt }) {
+      return rowFrom(await one(db.from('secret_tickets').insert({ token_hash: tokenHash, scope_type: scopeType, scope_id: scopeId, entries, created_by: createdBy, expires_at: ts(expiresAt) }).select(SECRET_TICKET).single()))
+    },
+    async redeemSecretTicket (tokenHash, at) {
+      const rows = await one(db.rpc('redeem_secret_ticket', { p_token_hash: tokenHash, p_at: ts(at) }))
+      return rowFrom((rows || [])[0] || null)
+    },
+    async secretTicketById (id) { return rowFrom(await one(db.from('secret_tickets').select(SECRET_TICKET).eq('id', id).maybeSingle())) },
+    async markSecretTicketStored (id, at) {
+      return (await one(db.from('secret_tickets').update({ stored_at: ts(at) }).eq('id', id).not('redeemed_at', 'is', null).is('stored_at', null).select('id'))).length > 0
+    },
+    async pruneSecretTickets (before) { await one(db.from('secret_tickets').delete().lt('expires_at', ts(before))) },
+    async createSecretRun ({ tokenHash, room, account, kind, label = '', expiresAt }) {
+      return rowFrom(await one(db.from('secret_runs').insert({ token_hash: tokenHash, room, account, kind, label, expires_at: ts(expiresAt) }).select(SECRET_RUN).single()))
+    },
+    async secretRunByToken (tokenHash) { return rowFrom(await one(db.from('secret_runs').select(SECRET_RUN).eq('token_hash', tokenHash).maybeSingle())) },
+    async secretRunById (id) { return rowFrom(await one(db.from('secret_runs').select(SECRET_RUN).eq('id', id).maybeSingle())) },
+    async revokeSecretRun (id, at) {
+      return (await one(db.from('secret_runs').update({ revoked_at: ts(at) }).eq('id', id).is('revoked_at', null).select('id'))).length > 0
+    },
+    async putSecretRunAsks (runId, asks) {
+      if (!asks.length) return
+      await one(db.from('secret_run_asks').insert(asks.map((a) => ({ run_id: runId, secret_id: a.secretId, name: a.name, state: a.state || 'asked' }))))
+    },
+    async listSecretRunAsks (runId) { return (await one(db.from('secret_run_asks').select(SECRET_ASK).eq('run_id', runId))).map(rowFrom) },
+    async answerSecretRunAsks (runId, state, at) {
+      return (await one(db.from('secret_run_asks').update({ state, answered_at: ts(at) }).eq('run_id', runId).eq('state', 'asked').select('run_id'))).length
+    },
+    async pendingSecretAsks (account, at) {
+      const runs = (await one(db.from('secret_runs').select(SECRET_RUN).eq('account', account).is('revoked_at', null).gt('expires_at', ts(at)).order('created_at'))).map(rowFrom)
+      if (!runs.length) return []
+      const asks = (await one(db.from('secret_run_asks').select(SECRET_ASK).in('run_id', runs.map((r) => r.id)).eq('state', 'asked'))).map(rowFrom)
+      return runs.map((run) => ({ run, asks: asks.filter((a) => a.runId === run.id) })).filter((x) => x.asks.length)
+    },
+    async recordSecretUse ({ secretId, runId, room, account, upstream, at }) {
+      await one(db.from('secret_uses').insert({ secret_id: secretId, run_id: runId, room, account, upstream, at: ts(at) }))
+      await one(db.from('secrets').update({ last_used_at: ts(at) }).eq('id', secretId))
+    },
+    async listSecretUses (secretIds, { limit = 100 } = {}) {
+      if (!secretIds.length) return []
+      return (await one(db.from('secret_uses').select(SECRET_USE).in('secret_id', secretIds).order('at', { ascending: false }).limit(limit))).map((r) => ({ ...rowFrom(r), at: ms(r.at) }))
     }
   }
 }

package/src/autowork.js

@@ -1,4 +1,4 @@
-// "Work on its own": when work comes to "<person>'s AI" (a task given to it, a merge sent to
+// "Work on its own": when work comes to "<person>'s AI" (a task given to it, a message to
 // it) and none of the person's AI sessions is live, Quilt can start the person's own AI tool
 // in its non-interactive mode, on their computer, in the session's folder — only when they
 // turned it on in Settings. The run talks through Quilt chat: it asks with quilt_message and
@@ -71,8 +71,6 @@ export function runPrompt ({ person, job, changeFiles, prompt = '' }) {
   if (job.kind === 'task') {
     lines.push(`${job.by || 'Someone'} gave ${person}'s AI a task on the board:`, `Task ${job.id}: ${job.title}`, '',
       'Read it in full with quilt_task, move it to "doing" with quilt_move_task when you start (that briefs you), and to "qa" with qaNotes when it is done and checked.')
-  } else if (job.kind === 'merge') {
-    lines.push(job.prompt.trim())
   } else if (job.kind === 'message') {
     lines.push(`${job.by || 'Someone'} wrote to ${person}'s AI in Quilt chat:`, '', String(job.text || '').trim(), '',
       `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.`)
@@ -211,14 +209,6 @@ export class AutoWork {
     }
   }
 
-  /** A merge sent to the person's AI. Resolves once it is queued; the run follows. */
-  sendMerge (session, { id, path: file, prompt }) {
-    const c = this.config()
-    if (!c.preset) throw new Error(`${c.tool || 'Your AI tool'} can't work on its own: open the merge in it instead`)
-    this.enqueue({ kind: 'merge', session, id, path: file, title: `merge ${file}`, prompt, by: session.name })
-    return { queued: true, tool: c.tool }
-  }
-
   enqueue (job) {
     this.queue.push(job)
     this.idle = this.idle.then(() => this.next()).catch(() => {})
@@ -262,7 +252,7 @@ export class AutoWork {
     const args = resumes
       ? p.resume({ ...o, prompt: replyPrompt({ run, reply: job.reply, resumes: true }) })
       : p.start({ ...o, prompt: job.kind === 'reply' ? replyPrompt({ run, reply: job.reply, resumes: false }) : run.prompt })
-    const label = job.kind === 'merge' ? job.title : (run.title || 'work')
+    const label = run.title || 'work'
     const started = this.now()
     let persona = null
     const r = await this.spawnRun(exe, args, {
@@ -296,15 +286,13 @@ export class AutoWork {
   }
 
   /**
-   * One plain line in chat for the person; the work stays where it was (a merge lets go of its
-   * file again). A tool that isn't signed in is said so plainly, never with one tool's fix.
+   * One plain line in chat for the person; the work stays where it was. A tool that isn't signed in is said so plainly, never with one tool's fix.
    */
   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)
     session.dropAutoPersona(run.via)
-    if (run.kind === 'merge' && run.path) session.releaseMergeClaim(run.path).catch(() => {})
   }
 
   notice (session, text, run = null) {

package/src/catchup.js

@@ -104,7 +104,7 @@ export function catchUpMarkdown (c, { ago = () => '' } = {}) {
   const m = c.mine || {}
   if (m.shared) out.push(`- Your ${plural(m.shared, 'change')} from while you were away went into the session.`)
   if (m.merged?.length) out.push(`- Combined with the session's changes: ${m.merged.map((p) => `\`${p}\``).join(', ')}.`)
-  if (m.conflicts?.length) out.push(`- Clashed with the session's changes (the session's version is in the file, yours is in the merge; see quilt_merges): ${m.conflicts.map((p) => `\`${p}\``).join(', ')}.`)
+  if (m.conflicts?.length) out.push(`- Held by someone else, so waiting: Quilt merges your changes in when they let go of ${m.conflicts.map((p) => `\`${p}\``).join(', ')}.`)
   if (c.backups?.length) out.push(`- Your copies of ${plural(c.backups.length, 'file')} differed from the session's and were replaced; they are kept: ${c.backups.map((b) => `\`${b.path}\` → \`${b.copy}\``).join(', ')}.`)
   out.push('Read quilt_history for the diffs before you change these files.')
   return out

package/src/clash.js

@@ -1,7 +1,8 @@
-// A clash between commits from outside and the session's uncommitted work is
-// handed to ONE AI, as a task on the board, instead of every folder behind on
-// that branch telling its AI to pull and resolve (several AIs starting the same
-// merge). Each folder that reports the clash works out the same owner from
+// Commits from outside that a folder can't bring in (git couldn't read a file
+// they change: too large, or behind a filter such as Git LFS) are handed to ONE
+// member as a task on the board, instead of every folder behind on that branch
+// telling its AI. Files both sides changed never come here: Quilt combines them
+// itself (upstream.js combine). Each folder that reports the clash works out the same owner from
 // presence; only the owner's Quilt writes the task, under an id derived from
 // the branch and the upstream commit, so two that race write the same task.
 // Pure: Session (reviewClash) reads presence and the board and applies these.
@@ -106,35 +107,22 @@ export function clashFiles (conflicts = []) {
   return [...new Set(conflicts.map((c) => c.path))].slice(0, MAX_FILES)
 }
 
-/** The task's description, as its first comment: each file and why, and what to do. */
+/** The task's description, as its first comment: each file and why. Nobody is asked to pull or merge. */
 export function clashBrief ({ branch, upstream, sha, behind, conflicts = [] }) {
-  const lines = [`${n(behind, 'commit')} on ${upstream} (up to ${sha.slice(0, 7)}) clash with the session's uncommitted work, so Quilt brought nothing in:`]
+  const lines = [`${n(behind, 'commit')} on ${upstream} (up to ${sha.slice(0, 7)}) change files Quilt can't read here, so it brought nothing in yet:`]
   for (const c of conflicts.slice(0, 30)) lines.push(`- ${c.path}: ${c.why}`)
   if (conflicts.length > 30) lines.push(`- and ${conflicts.length - 30} more`)
-  lines.push('', `In your folder on \`${branch}\`: run git pull, resolve those files and git add them. Quilt takes in the result and every other folder on \`${branch}\` follows yours, without merging again. Quilt closes this task by itself once the merge lands (a folder at ${sha.slice(0, 7)} or later with nothing clashing): no need to move it.`)
+  lines.push('', `Files both sides changed are combined by Quilt on its own; nothing here needs merging by hand. Once a folder on \`${branch}\` that can read these files is at ${sha.slice(0, 7)} or later, every other folder follows it and Quilt closes this task by itself: no need to move it.`)
   return lines.join('\n')
 }
 
 /** The notice for a member whose folder is behind but who is not merging: leave it to the owner. */
 export function leaveItNotice ({ label, upstream, task, facts }) {
-  return `${label} is merging the commits from ${upstream} (task ${task}); leave those files to them.${facts ? ` ${facts}` : ''}`
+  return `${label} is bringing in the commits from ${upstream} (task ${task}); leave those files to them.${facts ? ` ${facts}` : ''}`
 }
 
 /** What a folder that reports the clash knows about it, without the advice to pull. */
 export function clashFacts ({ branch, upstream, behind, conflicts = [] }) {
   const list = conflicts.slice(0, 4).map((c) => `${c.path} (${c.why})`).join('; ') + (conflicts.length > 4 ? `; and ${conflicts.length - 4} more` : '')
-  return `${branch} is ${n(behind, 'commit')} behind ${upstream}, and the session's uncommitted work clashes with them in ${list}.`
-}
-
-/**
- * The description of a clash the relay hands to a hosted agent (relay-upstream.js): no folder on
- * the branch is online, so the agent merges in the session itself, file by file. The change from
- * upstream for each file follows in the next comments.
- */
-export function relayClashBrief ({ branch, upstream, sha, base, behind, conflicts = [], compare = '' }) {
-  const lines = [`${n(behind, 'commit')} on ${upstream} (${base.slice(0, 7)} → ${sha.slice(0, 7)}) clash with the session's uncommitted work on \`${branch}\`, and no folder on \`${branch}\` that can bring commits in is online, so the relay brought nothing in:`]
-  for (const c of conflicts.slice(0, 20)) lines.push(`- ${c.path}: ${c.why}`)
-  if (conflicts.length > 20) lines.push(`- and ${conflicts.length - 20} more`)
-  lines.push('', `For each file: read it with quilt_read_file, fold in what ${upstream} changed (the next comments${compare ? `, or ${compare}` : ''}) while keeping the session's work, and write the merged file (quilt_write_file, or in your folder), without conflict markers. Each write of one of these files makes the relay look again at once: a file counts as merged when the lines that clashed were rewritten. If you merged a file differently (kept one side whole, say), move this task to QA when every file is done: that tells the relay the files are merged as they are. The rest of the commits then come in, and Quilt closes this task by itself. quilt_sync_branch asks the relay to look again too.`)
-  return lines.join('\n').slice(0, 2000)
+  return `${branch} is ${n(behind, 'commit')} behind ${upstream}, and Quilt can't read ${list} to bring them in.`
 }

package/src/control.js

@@ -6,9 +6,15 @@ import path from 'node:path'
 import crypto from 'node:crypto'
 import { renderStatus } from './status.js'
 import { migrateDir } from './legacy.js'
+import { createRun, waitRun, endRun, secretNames } from './secrets-client.js'
 
 export async function startControl (session, extras = {}) {
   const token = crypto.randomBytes(16).toString('hex')
+  // { api, token } for the accounts API as this session's identity (runner.js `apiAuth`).
+  const secretsApi = async () => {
+    if (!extras.apiAuth) throw new Error('This session is not signed in to Quilt, so it has no secrets. Sign in (quilt login) and join again.')
+    return extras.apiAuth()
+  }
   const routes = {
     'GET /status': (b) => {
       // To one of the AI sessions working through this app, "you" is that session (persona.js).
@@ -143,22 +149,17 @@ export async function startControl (session, extras = {}) {
       return r
     },
     'POST /tasks/delete': (b) => { session.deleteTask(b.id); return { tasks: session.taskList() } },
-    'GET /merges': () => {
-      const merges = session.mergeList()
-      // Agents are told the other version is under .quilt/merges/<id>/, so put
-      // it there on this machine too (base and ours are written once). A local
-      // record's versions are only on the opener's machine; skip any that fail.
-      for (const m of merges) {
-        if (m.state !== 'open' || m.local) continue
-        try { session.prepareMergeSend(m.id) } catch {}
-      }
-      return { merges }
-    },
-    'POST /merges/resolve': (b) => session.settleMerge(String(b.id || ''), { how: b.how }),
+    // Merges Quilt made on its own (session.js autoSettle), and files waiting for their holder to let go.
+    'GET /merges': () => ({ merges: session.mergeList() }),
     // quilt_clash: a file held because the session and GitHub changed the same lines (relay-clash.js).
     'POST /clash': (b) => session.clash({ action: String(b.action || ''), path: String(b.path || ''), content: typeof b.content === 'string' ? b.content : null, checks: b.checks && typeof b.checks === 'object' ? b.checks : null, force: b.force === true }),
-    'POST /merges/send': (b) => session.sendMerge(String(b.id || '')),
     'GET /rules': () => ({ text: session.projectRulesText() }),
+    // Secrets (`quilt run`, quilt_secret_names): asked of the API as this session's own identity
+    // (its person, or the agent it runs as). Run tokens and names only: never a value.
+    'POST /secrets/run': async (b) => createRun(await secretsApi(), { room: session.room, label: String(b.label || '').slice(0, 200) }),
+    'POST /secrets/run/wait': async (b) => waitRun(await secretsApi(), String(b.id || '')),
+    'POST /secrets/run/end': async (b) => endRun(await secretsApi(), String(b.id || '')),
+    'GET /secrets/names': async () => secretNames(await secretsApi(), session.room),
     'GET /info': (b) => ({ room: session.room, dir: session.root, name: session.actorName(b.via), person: session.name, kind: session.kind, invite: extras.invite || null, viewInvite: extras.viewInvite || null, access: session.access, pid: process.pid })
   }
   const server = http.createServer(async (req, res) => {
@@ -233,11 +234,13 @@ export function findDaemon (start = process.env.QUILT_DIR || process.cwd()) {
   }
 }
 
-export async function call (daemon, method, route, body) {
+/** `timeoutMs`: give up (throw) when the session hasn't answered by then (git's helpers: git must never wait on Quilt). */
+export async function call (daemon, method, route, body, { timeoutMs = 0 } = {}) {
   const res = await fetch(`http://127.0.0.1:${daemon.port}${route}`, {
     method,
     headers: { authorization: `Bearer ${daemon.token}`, 'content-type': 'application/json' },
-    body: body ? JSON.stringify(body) : undefined
+    body: body ? JSON.stringify(body) : undefined,
+    signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined
   })
   const json = await res.json()
   if (!res.ok) throw new Error(json.error || `HTTP ${res.status}`)

package/src/fsutil.js

@@ -4,12 +4,22 @@ import crypto from 'node:crypto'
 import { makeIgnore, isIgnored, scopeIgnore, IGNORE_FILES } from './pathrules.js'
 
 export { IGNORE_FILES } from './pathrules.js'
-export { MAX_TEXT_BYTES, MAX_BINARY_BYTES, LARGE_FILE_BYTES, MAX_STORED_BINARY_BYTES, isIgnored, isSafeRelPath, globMatcher, patternsOverlap } from './pathrules.js'
+export { MAX_TEXT_BYTES, MAX_BINARY_BYTES, LARGE_FILE_BYTES, MAX_STORED_BINARY_BYTES, CHAT_FILES, isIgnored, isSafeRelPath, globMatcher, patternsOverlap } from './pathrules.js'
 
 export function toPosix (p) {
   return p.split(path.sep).join('/')
 }
 
+/**
+ * Closes a chokidar watcher for good. chokidar calls its own add() when the last file it watches
+ * goes (to watch for its return), and add() reopens a closed watcher: a scan still under way at
+ * close (an index.lock that came and went) left a watch open that kept the process alive.
+ */
+export function closeWatcher (w) {
+  w.add = () => w
+  return w.close()
+}
+
 /**
  * Builds the ignore matcher from built-ins and every .gitignore / .quiltignore
  * in the project, each applying to its own folder. Folders already ignored

package/src/gitstate.js

@@ -11,7 +11,7 @@ import os from 'node:os'
 import path from 'node:path'
 import { execFile } from 'node:child_process'
 import { watch } from 'chokidar'
-import { looksBinary, sha1, MAX_STORED_BINARY_BYTES } from './fsutil.js'
+import { looksBinary, sha1, MAX_STORED_BINARY_BYTES, closeWatcher } from './fsutil.js'
 
 export const GIT_TIMEOUT_MS = 5000
 export const SETTLE_MS = 2000
@@ -343,6 +343,23 @@ export async function changesBetween (root, shaA, shaB) {
   return changes
 }
 
+/**
+ * When each path last changed in `from`..`to`, by commit time (ms): Map path -> ms, in one git log.
+ * What "newer" means for the lines both a catch-up's commits and the session changed (upstream.js combine).
+ */
+export async function commitTimes (root, from, to) {
+  const out = await run(root, ['log', '--format=%x1e%ct', '--name-only', '--no-renames', `${from}..${to}`])
+  const times = new Map()
+  if (out === null) return times
+  for (const chunk of out.split('\x1e')) {
+    const [ct, ...names] = chunk.split('\n')
+    const ms = Number(ct) * 1000
+    if (!Number.isFinite(ms) || !ms) continue
+    for (const rel of names) if (rel && !times.has(rel)) times.set(rel, ms) // newest first
+  }
+  return times
+}
+
 /** Paths that differ between two commits. */
 export async function changedBetween (root, shaA, shaB) {
   const changes = await changesBetween(root, shaA, shaB)
@@ -466,7 +483,7 @@ export function watchGit (root, onEvent) {
     }
   }
   watcher.on('add', onAny).on('change', onAny).on('unlink', onAny).on('addDir', onAny).on('unlinkDir', onAny)
-  return { close: () => Promise.all([watcher.close(), refs.close()]) }
+  return { close: () => Promise.all([closeWatcher(watcher), closeWatcher(refs)]) }
 }
 
 /** The repository's shared git directory (a worktree's .git/worktrees/<name> points at it), or null. */
@@ -561,6 +578,13 @@ export const shellQuote = (s) => `'${String(s).replace(/'/g, "'\\''")}'`
 
 const HOOK_MARK = '# Quilt pre-push hook'
 
+/**
+ * The Quilt CLI as git runs it (through sh: a helper starting with !, and the hook). In the desktop
+ * app `node` is the app itself, which without ELECTRON_RUN_AS_NODE opens as the app and never
+ * answers, so git waited for ever; plain node ignores it.
+ */
+const cliRun = (node, script) => `ELECTRON_RUN_AS_NODE=1 ${shellQuote(node)} ${shellQuote(script)}`
+
 /**
  * Lets an agent's folder use git like anyone: git asks Quilt for credentials for `host`
  * (`quilt git-credential`, which asks the running session, which asks the relay for a short-lived
@@ -573,7 +597,7 @@ const HOOK_MARK = '# Quilt pre-push hook'
 export async function installGitHelpers (root, { node, script, host = 'github.com', origin = '', identity = null }) {
   const dir = gitDir(root)
   if (!dir || !node || !script) return { helper: false, hook: false }
-  const cmd = (sub) => `!${shellQuote(node)} ${shellQuote(script)} ${sub} --dir ${shellQuote(root)}`
+  const cmd = (sub) => `!${cliRun(node, script)} ${sub} --dir ${shellQuote(root)}`
   let helper = false
   if (host) {
     // `origin`: the remote's scheme, host and port (the relay's git, http:// in tests); else https://<host>.
@@ -609,7 +633,7 @@ async function writeQuiltHook (root, { node, script }) {
   let now = ''
   try { now = fs.readFileSync(file, 'utf8') } catch {}
   if (now && !now.includes(HOOK_MARK)) return false
-  const want = `#!/bin/sh\n${HOOK_MARK}: pushes from this folder follow the session's git setting (git for everyone; for agents, quilt_agent_commits), and the session is told what was pushed.\nexec ${shellQuote(node)} ${shellQuote(script)} git-pre-push --dir ${shellQuote(root)} "$@"\n`
+  const want = `#!/bin/sh\n${HOOK_MARK}: pushes from this folder follow the session's git setting (git for everyone; for agents, quilt_agent_commits), and the session is told what was pushed.\n${cliRun(node, script).replace(/ /, ' exec ')} git-pre-push --dir ${shellQuote(root)} "$@"\n`
   if (now !== want) {
     fs.mkdirSync(path.dirname(file), { recursive: true })
     fs.writeFileSync(file, want, { mode: 0o755 })
@@ -646,7 +670,7 @@ export async function setPersonGit (root, { node, script, url = '', helper = fal
   for (const k of await quiltHelperKeys(root)) if (k !== key) await call(root, ['config', '--local', '--unset-all', k])
   let helperOn = false
   if (key) {
-    const want = `!${shellQuote(node)} ${shellQuote(script)} git-credential --dir ${shellQuote(root)} --fallback`
+    const want = `!${cliRun(node, script)} git-credential --dir ${shellQuote(root)} --fallback`
     const have = String((await call(root, ['config', '--local', '--get-all', key])).out || '').split('\n')
     if (have.length !== 2 || have[0] !== '' || have[1] !== want) {
       await call(root, ['config', '--local', '--replace-all', key, ''])

package/src/hooks.js

@@ -187,7 +187,7 @@ function mergesContext (merges) {
   }
   const shown = open.slice(0, 5).map(describe).join(', ')
   const more = open.length > 5 ? `, and ${open.length - 5} more` : ''
-  return `${open.length} file(s) need merging: ${shown}${more}. Run quilt_merges before editing those files; settle one with quilt_resolve_merge.`
+  return `${open.length} file(s) wait for whoever holds them: ${shown}${more}. Quilt merges those changes in by itself when they let go; leave those files alone until then.`
 }
 
 async function preEdit (event, d, api, state, say, name) {