heyquilt 0.3.122 → 0.3.138

package/src/connection.js

@@ -15,6 +15,7 @@ import {
 } from './protocol.js'
 import { signChallenge, RESERVED_ROOM } from './identity.js'
 import { PASS_REFRESH_MS } from './pass-source.js'
+import { isUpdateRefusal, withUpdateSteps } from './update-check.js'
 
 const ROOM_FULL_MESSAGE = 'This session is over the relay\'s size limit, so new changes can\'t be saved there. Start a new session, or host your own relay with a higher limit.'
 
@@ -22,9 +23,14 @@ const REQUEST_TIMEOUT_MS = 10000
 // A request the relay answers after pushing to GitHub: pushes to one repository go at least ten seconds apart
 // (relay-git.js PUSH_GAP_MS), so the answer can take longer than an ordinary one.
 export const PUSH_REQUEST_TIMEOUT_MS = 60 * 1000
+// Moving a session into its squares and back (the relay's quilt-migrate, -switch, -unswitch, -shadow,
+// -next) is many calls to Seam; a large session's takes minutes, and the relay answers when it is done.
+export const QUILT_MOVE_TIMEOUT_MS = 10 * 60 * 1000
 const IDENTITY_CHANGED = "This computer's Quilt identity changed. Sign out and sign in again."
 // Never quote the relay URL in errors: it names the room, and older relays may log it.
 const BAD_ADDRESS = "Couldn't connect to the relay: the address isn't valid."
+// The relay refused this app or CLI: an app too old for the session is told only how to update.
+const refusedBy = (reason) => new Error(isUpdateRefusal(reason) ? withUpdateSteps(reason) : `Relay refused connection: ${reason}`)
 // A pass that lapses this soon after connecting wasn't really valid: after a few in a
 // row, the clock is the likely culprit, and reconnecting won't help.
 const QUICK_EXPIRY_MS = 60 * 1000
@@ -58,7 +64,7 @@ export class Connection extends EventEmitter {
    * @param {number} [opts.livenessMs]  give up on a connection that stays silent this long
    * @param {string} [opts.tool]  the app or AI tool this is, for the session's audit trail
    */
-  constructor ({ server, room, secret, key, viewSecret, kind = 'human', name, identity, doc, branch = null, onStaleBranch = null, beforeRemote, features = FEATURES, passes = null, passRefreshMs = PASS_REFRESH_MS, livenessMs = LIVENESS_MS, tool = '' }) {
+  constructor ({ server, room, secret, key, viewSecret, kind = 'human', name, identity, doc, branch = null, onStaleBranch = null, beforeRemote, features = FEATURES, passes = null, passRefreshMs = PASS_REFRESH_MS, livenessMs = LIVENESS_MS, tool = '', roomDoc = true }) {
     super()
     if (room === RESERVED_ROOM) throw new Error(`"${RESERVED_ROOM}" is not a session name`)
     // Secrets travel in headers, never in the URL: proxies log URLs, and Fly's did (issue 011).
@@ -103,6 +109,11 @@ export class Connection extends EventEmitter {
     this.autoJoin = null // the id of the automatic join, whose refusal is said (branch-refused)
     this.roomSynced = false
     this.branchSynced = false
+    // roomDoc: false: only the branch is synced, never the room's document (chat, tasks, activity),
+    // nor anyone's presence. A folder's live block (live-block.js) is that: its app's own connection
+    // has the room already, so the block's would only download it all again at every square.
+    this.roomDocOn = roomDoc !== false
+    if (!this.roomDocOn) this.awareness.setLocalState(null)
     // Which document of the branch this app's copy belongs to (the relay starts a new one when a
     // branch is started again after being removed). While the relay hasn't said, a saved copy is
     // held back (branchHeld); a copy of an older one is never merged in: onStaleBranch(reply)
@@ -218,7 +229,7 @@ export class Connection extends EventEmitter {
         this.emit('fatal', new Error('This relay needs a relay key to start new sessions. Join a session someone started there with their invite link instead.'))
         this.close()
       } else if (res.statusCode === 401 || res.statusCode === 400 || res.statusCode === 403) {
-        this.emit('fatal', new Error(`Relay refused connection: ${reason}`))
+        this.emit('fatal', refusedBy(reason))
         this.close()
       } else if (res.statusCode === 413) {
         this.emit('fatal', new Error(ROOM_FULL_MESSAGE))
@@ -261,7 +272,7 @@ export class Connection extends EventEmitter {
         this.emit('fatal', Object.assign(new Error(String(reason) || 'The session owner did not let you in'), { denied: true }))
         this.close()
       } else if (code === CLOSE_AUTH_FAILED || code === CLOSE_NAME_TAKEN) {
-        this.emit('fatal', new Error(`Relay refused connection: ${String(reason) || 'identity check failed'}`))
+        this.emit('fatal', refusedBy(String(reason) || 'identity check failed'))
         this.close()
       } else if (code === CLOSE_ROOM_FULL) {
         this.emit('fatal', new Error(ROOM_FULL_MESSAGE))
@@ -342,7 +353,8 @@ export class Connection extends EventEmitter {
   }
 
   startSync () {
-    this.send(syncStep1Message(this.doc))
+    if (this.roomDocOn) this.send(syncStep1Message(this.doc))
+    else this.roomSynced = true
     if (this.branchKey !== null) {
       // The relay handles messages in order: the join lands before the branch's sync step 1.
       const id = crypto.randomBytes(8).toString('hex')
@@ -353,6 +365,7 @@ export class Connection extends EventEmitter {
       if (this.branchEpoch) this.branchHeld = true
       else this.send(syncStep1Message(this.branchDoc, this.branchKey))
     }
+    if (!this.roomDocOn) return this.noteSynced()
     // Set again rather than resent: that moves our clock on, so the relay takes the state
     // even when it still holds the clock from before a drop (it would ignore a repeat).
     const mine = this.awareness.getLocalState()
@@ -367,7 +380,7 @@ export class Connection extends EventEmitter {
     const type = decoding.readVarUint(dec)
     if (type === MSG_SYNC) {
       const docId = decoding.readVarString(dec)
-      const doc = docId === ROOM_DOC ? this.doc : docId === this.branchKey && !this.branchHeld ? this.branchDoc : null
+      const doc = docId === ROOM_DOC ? (this.roomDocOn ? this.doc : null) : docId === this.branchKey && !this.branchHeld ? this.branchDoc : null
       if (!doc) return // a branch this connection has left (or whose document the relay hasn't confirmed yet)
       // Give the owner a chance to capture unsaved local edits so remote
       // changes merge with them instead of overwriting them.
@@ -382,10 +395,24 @@ export class Connection extends EventEmitter {
         this.noteSynced()
       }
     } else if (type === MSG_BRANCHES) {
-      const { branches, reply, pushed, quilt } = JSON.parse(decoding.readVarString(dec))
+      const { branches, reply, pushed, quilt, shadow, readOnly, moving, force, importing } = JSON.parse(decoding.readVarString(dec))
+      // "Make this a quilt" on a session with a git remote: Seam imports it ({ slug, repo }), or null.
+      const im = importing && typeof importing.repo === 'string' ? { slug: String(importing.slug || ''), repo: importing.repo } : null
+      if (JSON.stringify(im) !== JSON.stringify(this.importing || null)) { this.importing = im; this.emit('importing', im) }
+      // The forced date (16 flag 9): { at, remote, migrate? } before or at it, { stopped: { at, why } } once live sync stopped; else none.
+      const fz = force && typeof force === 'object' ? force : null
+      if (JSON.stringify(fz) !== JSON.stringify(this.force || null)) { this.force = fz; this.emit('force', fz) }
+      // At layout 3 a write of ours reached a read-only branch document: the relay did not keep it.
+      if (readOnly && typeof readOnly.why === 'string') this.emit('read-only', readOnly)
       // The session is a quilt (Seam): its link, or null while it is not.
       const link = quilt && typeof quilt.id === 'string' ? quilt : null
       if (JSON.stringify(link) !== JSON.stringify(this.quilt || null)) { this.quilt = link; this.emit('quilt', link) }
+      // The quilt an import of the session's git remote fills while git is still the authority (16 step 1).
+      const sh = shadow && typeof shadow.id === 'string' ? { id: shadow.id, slug: String(shadow.slug || '') } : null
+      if (JSON.stringify(sh) !== JSON.stringify(this.quiltShadow || null)) { this.quiltShadow = sh; this.emit('quilt-shadow', sh) }
+      // The owner is moving the session into Seam ('in') or back to its branches ('back') right now: { kind, since }, or null.
+      const mv = moving && (moving.kind === 'in' || moving.kind === 'back') ? { kind: moving.kind, since: Number(moving.since) || 0 } : null
+      if (JSON.stringify(mv) !== JSON.stringify(this.moving || null)) { this.moving = mv; this.emit('moving', mv) }
       // GitHub moved a branch the session follows (the relay heard it from GitHub): look now.
       if (pushed && typeof pushed.branch === 'string') this.emit('pushed', pushed)
       if (reply && this.joining && reply.id === this.joining.id) {
@@ -414,9 +441,9 @@ export class Connection extends EventEmitter {
       if (Array.isArray(branches)) this.emit('branches', branches)
       this.settle(reply, 'the relay refused that branch change')
     } else if (type === MSG_AWARENESS) {
-      awarenessProtocol.applyAwarenessUpdate(this.awareness, decoding.readVarUint8Array(dec), REMOTE)
+      if (this.roomDocOn) awarenessProtocol.applyAwarenessUpdate(this.awareness, decoding.readVarUint8Array(dec), REMOTE)
     } else if (type === MSG_QUERY_AWARENESS) {
-      this.send(awarenessMessage(this.awareness, [...this.awareness.getStates().keys()]))
+      if (this.roomDocOn) this.send(awarenessMessage(this.awareness, [...this.awareness.getStates().keys()]))
     } else if (type === MSG_ACCESS) {
       const was = this.access
       this.access = JSON.parse(decoding.readVarString(dec))
@@ -486,7 +513,7 @@ export class Connection extends EventEmitter {
   }
 
   /** Any other branch request (remove). */
-  branchRequest (req) { return this.request(MSG_BRANCH, req, 'branch changes') }
+  branchRequest (req, { timeoutMs = REQUEST_TIMEOUT_MS } = {}) { return this.request(MSG_BRANCH, req, 'branch changes', null, timeoutMs) }
 
   waitForBranchSync () {
     if (this.branchSynced) return Promise.resolve()

package/src/control.js

@@ -11,6 +11,14 @@ import { createRun, waitRun, endRun, secretNames, apiCall } from './secrets-clie
 import { runMailTool, MAIL_TOOLS } from './mail-tools.js'
 import { runWakeTool } from './wake-tool.js'
 import { wakeCheck } from './wake.js'
+import { seamAccess, sessionCredential } from './seam-access.js'
+import { runSessionSeamTool } from './session-seam.js'
+import { appSeamUrl } from './seam-url.js'
+import { squareFor } from './session-follow.js'
+import { shareWithPeople } from './session-layout3.js'
+import { QUILT_MOVE_TIMEOUT_MS } from './connection.js'
+import { FEATURES } from './protocol.js'
+import { currentVersion } from './releases.js'
 
 export async function startControl (session, extras = {}) {
   const token = crypto.randomBytes(16).toString('hex')
@@ -22,10 +30,45 @@ export async function startControl (session, extras = {}) {
   // Step 2 of joining (wake.js): an agent that hasn't chosen how Quilt wakes it is reminded with each answer.
   const wake = wakeCheck({
     fetchWake: async () => {
-      if (session.kind !== 'agent' || !extras.apiAuth) return { method: 'n/a' }
+      // A person's cloud AI (aiOf) is woken by its machine (autowork.js), never asked how.
+      if (session.kind !== 'agent' || session.aiOf || !extras.apiAuth) return { method: 'n/a' }
       return (await apiCall(await secretsApi(), 'GET', '/v1/agents/me/wake')).wake
     }
   })
+  // Seam's tools for this folder's AI sessions, in a session that is a quilt (session-seam.js), as
+  // this session's member: its person, or its agent on a cloud machine (seam-access.js).
+  // Kept on the session, so its AI's runs (autowork.js) read Seam as the same member.
+  if (extras.apiAuth && !session.apiAuth) session.apiAuth = extras.apiAuth
+  const seam = session.seamMember ? session.seamMember() : (session.seam || (session.seam = seamAccess({ api: () => appSeamUrl(), credential: sessionCredential({ apiAuth: extras.apiAuth, account: readAccount }) })))
+  const shared = new Set() // squares this person holds and has shared with the session's other people
+  const seamTool = async (b) => {
+    const q = session.quilt
+    if (!q || !q.id) return { content: [{ type: 'text', text: 'This session is not a quilt, so it has no Seam tools.' }], isError: true }
+    const branch = session.squareBranchKey ? session.squareBranchKey() : session.branchKey()
+    const at = squareFor(q, branch)
+    const square = at ? at.square : ((q.squares || {})[branch] || null)
+    const fail = (text) => ({ content: [{ type: 'text', text }], isError: true })
+    // The folder's live block on that square: the folder itself, following it in place, or a
+    // separate one (session-follow.js). Its commit is `quilt commit`'s: what the relay holds.
+    const f = session.squareFollower
+    const here = f && f.here && at && f.here.square === at.square ? f.here : null
+    const sep = f && f.following && at && f.following.square === at.square ? f.following : null
+    const live = (here && here.block) || (sep && sep.block) || null
+    if (here && !here.block && (b.tool === 'seam_commit' || b.tool === 'seam_merge')) return fail(here.problem ? `This folder can't follow its square yet (${here.problem}); Quilt tries again by itself.` : 'This folder is still starting to follow its square; try again in a moment.')
+    let c
+    try { c = await seam.client(q.id, square ? [square] : []) } catch (err) { return fail(err.message) }
+    // The folder's live work is read and committed as this member.
+    if (live) live.client = c.client
+    if (c.person && square && !shared.has(square)) {
+      shared.add(square)
+      // The square's holder shares it with the session's other people, so their AIs (working for them) write there too.
+      shareWithPeople(c.client, q.id, square, session.members || []).catch(() => shared.delete(square))
+    }
+    const next = at ? async () => session.conn.branchRequest({ op: 'quilt-next', token: c.token, branch }, { timeoutMs: QUILT_MOVE_TIMEOUT_MS }) : null
+    return runSessionSeamTool(String(b.tool || ''), b.args || {}, { client: c.client, quilt: q.id, square, live, next, branch })
+  }
+  // The app's square panel (ui-server.js) commits and merges through the same tools, as the same member.
+  session.seamTool = seamTool
   const routes = {
     'GET /status': (b) => {
       // To one of the AI sessions working through this app, "you" is that session (persona.js).
@@ -99,7 +142,8 @@ export async function startControl (session, extras = {}) {
     'POST /agent': (b) => { session.addAgent(b.client); return { ok: true } },
     'POST /feed': (b) => ({ entries: session.agentFeedFor(b.who, { limit: Math.min(Number(b.limit) || 40, 300) }) }),
     // The chronology: { path, by, since, task, limit } (see Session.historyQuery).
-    'POST /history': (b) => ({ entries: session.historyQuery(b) }),
+    // In a session linked to a quilt (Seam), the quilt's log too (Session.historyLinked): { entries, note? }.
+    'POST /history': (b) => session.historyLinked(b),
     'GET /tree': () => session.tree(),
     'POST /sharing': (b) => ({ on: session.setAgentSharing(b.on !== false) }),
     'GET /commits': () => session.commitStatus({ includeMe: false }),
@@ -111,13 +155,21 @@ export async function startControl (session, extras = {}) {
     'POST /quilt-plan': () => session.quiltPlan(),
     // The quilt this session is (Seam), as the relay last said; null while it is not (session-seam.js).
     'GET /quilt': () => ({ quilt: session.quilt || null }),
+    // One of Seam's tools (session-seam.js SEAM_SESSION_TOOLS), { tool, args }: an MCP tool result.
+    'POST /seam': (b) => seamTool(b),
     // `quilt session migrate`: the relay makes the session a quilt, as its owner (their sign-in).
     'POST /quilt-migrate': () => session.quiltMigrate(process.env.SEAM_TOKEN || (readAccount() || {}).token),
+    // "Make this a quilt" (`quilt session migrate`, the app's button): made a quilt and moved into its squares in one go.
+    'POST /quilt-make': () => session.quiltMake(process.env.SEAM_TOKEN || (readAccount() || {}).token),
     // `quilt session migrate --switch` / `--back`: the session's files into its squares (layout 3), or back.
     'POST /quilt-switch': () => session.quiltSwitch(process.env.SEAM_TOKEN || (readAccount() || {}).token),
-    'POST /quilt-unswitch': () => session.quiltUnswitch(),
+    'POST /quilt-unswitch': (b) => session.quiltUnswitch(process.env.SEAM_TOKEN || (readAccount() || {}).token, Array.isArray(b.carried) ? b.carried : []),
+    // `quilt session migrate --shadow <quilt>`: link the session to the quilt an import of its git remote fills (16 step 1).
+    'POST /quilt-shadow': (b) => session.quiltShadowLink(process.env.SEAM_TOKEN || (readAccount() || {}).token, b.quilt ?? null),
     // `quilt session follow <folder>`: at layout 3, that folder follows this branch's square, live.
-    'POST /quilt-follow': (b) => session.quiltFollow(process.env.SEAM_TOKEN || (readAccount() || {}).token, b.dir),
+    'POST /quilt-follow': (b) => session.quiltFollow(null, b.dir),
+    // `quilt commit <message>`: at layout 3, the square this folder follows is committed, as this person.
+    'POST /square-commit': (b) => session.squareCommit(String(b.message || '')),
     'POST /commit-request': (b) => session.requestCommit(b.message, { files: b.files == null ? null : b.files, description: b.description || '', task: b.task || null, via: b.via ? String(b.via) : null }),
     // quilt_commit: the relay commits the session's copy of the files to GitHub (relay-commit.js).
     'POST /agent-commits': (b) => session.setAgentCommits(b.mode),
@@ -221,7 +273,8 @@ export async function startControl (session, extras = {}) {
       const auth = await secretsApi()
       return { text: await runMailTool(b.tool, b.args && typeof b.args === 'object' ? b.args : {}, { call: (method, route, body) => apiCall(auth, method, route, body), room: session.room, me: session.actorName ? session.actorName(b.via) : session.name }) }
     },
-    '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 })
+    // `version` and `features` (what this app tells the relay it can do): the CLI checks them before a move (bin/quilt.js).
+    '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, version: appVersion(), features: session.features || FEATURES })
   }
   const server = http.createServer(async (req, res) => {
     const reply = (code, body) => {
@@ -299,15 +352,76 @@ export function findDaemon (start = process.env.QUILT_DIR || process.cwd()) {
   }
 }
 
-/** `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,
-    signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined
+const appVersion = () => { try { return currentVersion() } catch { return '' } }
+
+/**
+ * `timeoutMs`: give up (throw) when the session hasn't answered by then (git's helpers: git must never wait on Quilt).
+ * Without it, it waits as long as the session takes (a move into Seam can take minutes): node:http, not fetch, whose
+ * own limit gave up after 5 minutes with nothing but "fetch failed". A session that can't be reached, or that
+ * stopped while answering, throws with what happened and what to do (`unreachable`).
+ */
+export function call (daemon, method, route, body, { timeoutMs = 0 } = {}) {
+  const data = body ? JSON.stringify(body) : null
+  return new Promise((resolve, reject) => {
+    let timer = null
+    let late = null // the timeout's error, once it fired: whatever the socket says after it
+    const failed = (err) => { clearTimeout(timer); reject(late || (err.name === 'TimeoutError' ? err : unreachable(daemon, err))) }
+    const req = http.request({
+      host: '127.0.0.1',
+      port: daemon.port,
+      path: route,
+      method,
+      // A connection each: a kept-alive one outlives an app that restarted, and the next call would find it cut.
+      agent: false,
+      headers: { authorization: `Bearer ${daemon.token}`, 'content-type': 'application/json', ...(data ? { 'content-length': Buffer.byteLength(data) } : {}) }
+    }, (res) => {
+      let raw = ''
+      res.setEncoding('utf8')
+      res.on('data', (c) => { raw += c })
+      res.on('error', failed)
+      res.on('end', () => {
+        clearTimeout(timer)
+        let json
+        try { json = JSON.parse(raw) } catch { return reject(new Error(`Quilt's app sent something that isn't an answer (HTTP ${res.statusCode})`)) }
+        if (res.statusCode < 200 || res.statusCode >= 300) return reject(Object.assign(new Error(json.error || `HTTP ${res.statusCode}`), { status: res.statusCode }))
+        resolve(json)
+      })
+    })
+    req.on('error', failed)
+    if (timeoutMs) {
+      timer = setTimeout(() => {
+        late = Object.assign(new Error(`The session in ${daemon.dir || 'this folder'} did not answer within ${Math.round(timeoutMs / 1000)} s`), { name: 'TimeoutError' })
+        req.destroy(late)
+      }, timeoutMs)
+    }
+    req.end(data || undefined)
   })
-  const json = await res.json()
-  if (!res.ok) throw new Error(json.error || `HTTP ${res.status}`)
-  return json
+}
+
+/**
+ * The control server couldn't be reached (nothing listens: the app closed this session or restarted), or
+ * it closed the connection before answering (the session stopped meanwhile: left, quit, or sent away by
+ * the relay). `cut` tells the two apart for callers that say more (a move into Seam goes on without the app).
+ */
+export function unreachable (daemon, err) {
+  const code = (err && err.code) || ''
+  const where = daemon && daemon.dir ? ` for ${daemon.dir}` : ''
+  const cut = code !== 'ECONNREFUSED'
+  const msg = cut
+    ? `Quilt's app${where} stopped answering in the middle of this (${code || err.message}): the session there stopped (left, Quilt quit or restarted, or the relay sent this app away to update). Open the session in Quilt again, then check before trying again.`
+    : `Quilt's app${where} isn't answering: the session there is not running any more (Quilt quit, restarted, or left it). Open it in Quilt (or run quilt join here), then try again.`
+  return Object.assign(new Error(msg), { unreachable: true, cut, code })
+}
+
+/**
+ * Why `quilt session migrate` (or --switch, --back) must not start through this app, from its GET /info,
+ * or null. The move ends by sending away every app that can't follow a square (no `quilt-folders`): the
+ * owner's own app too, cutting this command's answer off mid-way. An app older than this check says
+ * neither its features nor its version; `cliVersion` is the quilt command's own.
+ */
+export function moveRefusal (info, cliVersion = '') {
+  const features = info && typeof info.features === 'string' ? info.features.split(',') : null
+  if (features && features.includes('quilt-folders')) return null
+  const was = info && info.version ? ` (${info.version})` : ''
+  return `Quilt's app for this folder${was} is older than this quilt command${cliVersion ? ` (${cliVersion})` : ''}: the move sends it away to update at the end, and this command would lose its answer. Update Quilt, or restart it so it runs the new version, then run this again.`
 }

package/src/force-date.js

@@ -0,0 +1,27 @@
+// The forced date (Seam's plans/quilt-source-control/16, flag 9): QUILT_SOURCE_FORCE_AT=<date> on the
+// relay. Unset (or not a date), nothing happens. From the date on, a session still in git mode is
+// moved on without anyone losing work: one with no git remote becomes a quilt without history on its
+// owner's next open; one with a git remote that has not cut over keeps chat, tasks, the agent feed and
+// the audit trail, and its live file sync stops for good (git, its remote, clones and CI untouched).
+// Pure: no I/O (test/unit/force-date.test.js). The words are in ui/force-words.js, which the app loads too.
+export { syncStoppedWords, forceAheadWords } from './ui/force-words.js'
+
+/** The date as ms, or null when unset or not a date. */
+export function forceAtMs (env = process.env) {
+  const v = String(env.QUILT_SOURCE_FORCE_AT || '').trim()
+  if (!v) return null
+  const ms = Date.parse(v)
+  return Number.isFinite(ms) ? ms : null
+}
+
+/**
+ * What the date means for a session now: null (no date, not yet, or already a quilt in its squares),
+ * 'stop' (a git remote, not cut over: live sync stops), or 'migrate' (no git remote: its owner's next
+ * open makes it a quilt without history).
+ */
+export function forcedAction ({ at, now = Date.now(), layout = 2, remote = false, stopped = false }) {
+  if (stopped) return 'stop'
+  if (at == null || now < at || layout === 3) return null
+  return remote ? 'stop' : 'migrate'
+}
+

package/src/fsutil.js

@@ -1,7 +1,8 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import crypto from 'node:crypto'
-import { makeIgnore, isIgnored, scopeIgnore, IGNORE_FILES } from './pathrules.js'
+import { isUtf8 } from 'node:buffer'
+import { makeIgnore, isIgnored, scopeIgnore, submodulePathsIn, 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, CHAT_FILES, isIgnored, isSafeRelPath, globMatcher, patternsOverlap } from './pathrules.js'
@@ -27,6 +28,9 @@ export function closeWatcher (w) {
  */
 export function loadIgnore (root) {
   const ig = makeIgnore()
+  // A submodule (.gitmodules) is a repository of its own that git keeps as one commit id: its files
+  // are its own git's, never the session's (nor a Seam square's, which holds it as a gitlink).
+  for (const p of submodulePaths(root)) ig.add(`/${p}`)
   const visit = (dirRel) => {
     const dir = path.join(root, dirRel)
     for (const file of IGNORE_FILES) {
@@ -44,6 +48,11 @@ export function loadIgnore (root) {
   return ig
 }
 
+/** The folders .gitmodules names as submodules (`path = …`), as safe relative paths. */
+export function submodulePaths (root) {
+  try { return submodulePathsIn(fs.readFileSync(path.join(root, '.gitmodules'), 'utf8')) } catch { return [] }
+}
+
 /**
  * Resolves a relative path to an absolute one inside root, making sure no
  * symlinked parent directory points outside of it (or nowhere: a dangling
@@ -71,8 +80,9 @@ export function resolveInside (root, rel) {
 export function looksBinary (buf) {
   const n = Math.min(buf.length, 8000)
   for (let i = 0; i < n; i++) if (buf[i] === 0) return true
-  // Invalid UTF-8 is treated as binary so it round-trips byte for byte.
-  return !Buffer.from(buf.toString('utf8'), 'utf8').equals(buf)
+  // Invalid UTF-8 is treated as binary so it round-trips byte for byte. Checked in place: decoding
+  // and encoding every file again to compare made two copies of each one.
+  return !isUtf8(buf)
 }
 
 export function sha1 (buf) {

package/src/gitstate.js

@@ -916,8 +916,44 @@ export async function committedAs (root, sha, rel, text) {
   return blob.trim() !== '' && blob.trim() === hashed.trim()
 }
 
-export async function blobAt (root, sha, rel) {
-  const out = await run(root, ['cat-file', '--filters', `${sha}:${rel}`], { buffer: true })
+/** Which of `paths` are links (mode 120000) at commit `sha`: a Set, or null when git can't say. */
+export async function linksAt (root, sha, paths) {
+  if (!paths.length) return new Set()
+  const out = await run(root, ['ls-tree', '-z', sha, '--', ...paths])
+  if (out === null) return null
+  return new Set(out.split('\0').filter((l) => l.startsWith('120000 ')).map((l) => l.slice(l.indexOf('\t') + 1)))
+}
+
+/**
+ * The paths a folder's branch changed since it left the remote's default branch: `committed`, from
+ * the merge base of HEAD and origin/HEAD (else origin/main, origin/master) to HEAD; `uncommitted`,
+ * what differs from HEAD (staged or not, deletions too) and files git does not track and does not
+ * ignore. `gitDir` reads a .git kept elsewhere (set aside while the folder follows a square). Two
+ * Sets, or null when git can't say (no remote default branch, no common history).
+ */
+export async function ownSinceFork (root, { gitDir = null } = {}) {
+  const opts = gitDir ? { env: { GIT_DIR: gitDir, GIT_WORK_TREE: root } } : {}
+  let main = ''
+  for (const ref of ['refs/remotes/origin/HEAD', 'refs/remotes/origin/main', 'refs/remotes/origin/master']) {
+    main = ((await run(root, ['rev-parse', '-q', '--verify', `${ref}^{commit}`], opts)) || '').trim()
+    if (main) break
+  }
+  if (!main) return null
+  const fork = ((await run(root, ['merge-base', 'HEAD', main], opts)) || '').trim()
+  if (!fork) return null
+  const lists = [
+    await run(root, ['diff', '--no-renames', '--no-ext-diff', '--name-only', '-z', fork, 'HEAD'], opts),
+    await run(root, ['diff', '--no-renames', '--no-ext-diff', '--name-only', '-z', 'HEAD'], opts),
+    await run(root, ['ls-files', '--others', '--exclude-standard', '--exclude=/.quilt/', '-z'], opts)
+  ]
+  if (lists.some((l) => l === null)) return null
+  const names = (l) => l.split('\0').filter(Boolean)
+  return { committed: new Set(names(lists[0])), uncommitted: new Set([...names(lists[1]), ...names(lists[2])]) }
+}
+
+/** A file's bytes at commit `sha` (null when git can't say); `gitDir` reads from a .git kept elsewhere (set aside while the folder follows a square). */
+export async function blobAt (root, sha, rel, { gitDir = null } = {}) {
+  const out = await run(root, ['cat-file', '--filters', `${sha}:${rel}`], { buffer: true, ...(gitDir ? { env: { GIT_DIR: gitDir, GIT_WORK_TREE: root } } : {}) })
   return out === null ? null : out
 }
 

package/src/history.js

@@ -256,14 +256,16 @@ export const LEGACY_DAYS = 90
 
 /**
  * The chronology once the session became a quilt at `at` (an ISO date, meta.quilt.at): entries from
- * before then are its legacy tail (plans/quilt-source-control/16), marked `legacy: true` for
+ * before then are its legacy tail (Seam's plans/quilt-source-control/16), marked `legacy: true` for
  * LEGACY_DAYS and then left out. Not a quilt (no `at`): the entries as they are.
  */
-export function legacyTail (entries, { at, now = Date.now() } = {}) {
+export function legacyTail (entries, { at, now = Date.now(), history = false } = {}) {
   const t = at ? Date.parse(at) : NaN
   if (!Number.isFinite(t)) return entries
   if (now - t > LEGACY_DAYS * 24 * 60 * 60 * 1000) return entries.filter((e) => !(e && e.ts < t))
-  return entries.map((e) => e && e.ts < t ? { ...e, legacy: true } : e)
+  // With history (the quilt is the session's imported git remote), git's own writes before then
+  // (pulls, first copies) are the log's imported patches: they are dropped, not shown twice.
+  return entries.filter((e) => !(history && e && e.ts < t && (e.pulled || e.seed))).map((e) => e && e.ts < t ? { ...e, legacy: true } : e)
 }
 
 function ago (ts, now) {
@@ -279,6 +281,14 @@ export function formatHistory (list, { withDiff = false, now = Date.now() } = {}
   if (!list.length) return 'No changes match.'
   const out = []
   for (const e of list) {
+    if (e.seam) {
+      // A commit in the quilt's log (quilt-history.js): who, which patch, its message, how many files.
+      const where = e.patch ? `patch ${e.patch.line && e.patch.line !== 'main' ? `${e.patch.line}:` : ''}${e.patch.no}` : `commit ${e.short || String(e.commit || '').slice(0, 12)}`
+      const n = e.files ? ` (${e.files} file${e.files === 1 ? '' : 's'})` : ''
+      out.push(`[${ago(e.ts, now)}] ${e.by} committed ${where}: ${e.message || '(no message)'}${n}${e.task ? ` [task ${e.task.id}]` : ''}`)
+      if (withDiff && e.diff) out.push(e.diff, '')
+      continue
+    }
     const span = e.from && e.ts - e.from > 60000 ? ` over ${Math.round((e.ts - e.from) / 60000)}m` : ''
     const what = e.detail ? ` (${e.detail})` : ''
     const task = e.task ? ` for "${e.task.title}" [${e.task.id}]` : ''