heyquilt 0.3.140 → 0.3.141

package/RELEASES.md

@@ -11,6 +11,10 @@ Format: `## <version> — <YYYY-MM-DD>`, an optional one-line summary, then bull
 Lead each bullet with a short bold phrase. Inline `code` and **bold** are rendered;
 nothing else is.
 
+## 0.3.141 — 2026-11-01
+
+- **A new, empty folder joining a session that is already in Seam takes the square as it is.** Its first files come from the session's old copy of the branch, and before, a folder without git could start following its square while that old copy was still being written to it, so every older file went into the square as its own edits (an agent's new folder put 166 stale files into main's square). Now the folder's own syncing stops before it follows the square, and nothing it got from the session is ever counted as its edits.
+
 ## 0.3.140 — 2026-11-01
 
 0.3.139 was tagged but never published; everything meant for it is here.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyquilt",
-  "version": "0.3.140",
+  "version": "0.3.141",
   "description": "Real-time, tool-agnostic pair vibe coding: sync a project folder live between collaborators using any AI coding tool.",
   "author": {
     "name": "Daniel Carmichael",

package/src/session-follow.js

@@ -307,8 +307,9 @@ export class SquareFollower {
     const s = this.session
     // Held before the first await: nothing of the folder reaches the read-only branch document while the block opens.
     const at = this.inPlaceOn() ? squareFor(quilt, s.squareBranchKey ? s.squareBranchKey() : s.branchKey()) : null
-    if (at && s.enterSquare && !(this.here && this.here.square === at.square)) s.enterSquare(at, quilt)
-    const next = this.turn.then(() => this.settle(quilt)).catch((err) => { if (s.log) s.log(`🧵 ${err.message}`) })
+    const entered = at && s.enterSquare && !(this.here && this.here.square === at.square) ? at.square : null
+    if (entered) s.enterSquare(at, quilt)
+    const next = this.turn.then(() => this.settle(quilt, entered)).catch((err) => { if (s.log) s.log(`🧵 ${err.message}`) })
     this.turn = next
     // A merge onto main moves a branch on (quiltNext), and the relay says so: the other squares may be behind now.
     next.then(() => this.catchUpSoon())
@@ -318,7 +319,8 @@ export class SquareFollower {
   /** Seam on for the app, a folder of the session's own, and a session that can hold its sync (a Session). */
   inPlaceOn () { return !!(appSeamUrl() && this.session.root && this.session.enterSquare) }
 
-  async settle (quilt) {
+  /** `entered`: the square onQuilt already held the session's sync for. */
+  async settle (quilt, entered = null) {
     const s = this.session
     const at = this.inPlaceOn() ? squareFor(quilt, s.squareBranchKey ? s.squareBranchKey() : s.branchKey()) : null
     // The separate folder lets go of a square the branch no longer has (switched back, moved).
@@ -340,6 +342,11 @@ export class SquareFollower {
       } else if (s.log) s.log(`🧵 this folder left square ${squareShort(was)}: its branch is on ${squareShort(at.square)} now.`)
     }
     if (!at || (this.here && this.here.square === at.square)) return
+    // The branch may only be known now (a folder without git learns the room's default branch after
+    // the relay's quilt message): the session's own sync holds before the block opens, every time, or
+    // it writes the read-only branch document's older copy over the square's files and the block takes
+    // that for this member's edits (2026-11-01: an agent's new folder put 166 stale files into main's square).
+    if (s.enterSquare && entered !== at.square) s.enterSquare(at, quilt)
     await this.openHere(at, quilt)
   }
 
@@ -349,13 +356,18 @@ export class SquareFollower {
     const here = { square: at.square, quilt, block: null, problem: '', opening: true }
     this.here = here
     if (s.scheduleStatusWrite) s.scheduleStatusWrite()
+    // A folder that joined the quilt empty (Session.joinedEmpty): what it has is the session's sync from
+    // the read-only branch document, an older copy of the square's files. Its first look takes nothing
+    // of that for its edits (no refused writes, boxes or branch work of its own); only a file changed
+    // on disk since the session wrote it is the member's.
+    const empty = !fresh && !!s.joinedEmpty
     try {
       // Edits the read-only branch document refused (they reached it after the switch) are the folder's too.
-      const unsent = !fresh && s.unsentPaths ? await s.unsentPaths().catch(() => null) : null
+      const unsent = !fresh && !empty && s.unsentPaths ? await s.unsentPaths().catch(() => null) : null
       const block = await this.open({
         dir: s.root,
         // A square opened for this folder's branch (Session.openSquareHere: the branch had none) takes the folder as it is: its files are the work.
-        inPlace: fresh ? { edited: () => false, fresh: true } : s.folderWins === at.square ? { edited: () => true } : { edited: (p) => s.editedSinceSync(p) || !!(unsent && unsent.has(p)) || !!(s.boxedHere && s.boxedHere(p)), boxed: (p) => !!(s.boxedHere && s.boxedHere(p)), heldBack: (p) => !!(s.heldBackHere && s.heldBackHere(p)), synced: (p) => !!(s.syncedHere && s.syncedHere(p)), base: s.syncedText ? (p) => s.syncedText(p) : null, own: () => (s.branchOwnPaths ? s.branchOwnPaths() : null), atTip: ((quilt && quilt.atTip) || []).includes(s.squareBranchKey ? s.squareBranchKey() : s.branchKey()) },
+        inPlace: fresh ? { edited: () => false, fresh: true } : empty ? { edited: (p) => !!(s.editedSinceSync && s.editedSinceSync(p)), fresh: true } : s.folderWins === at.square ? { edited: () => true } : { edited: (p) => s.editedSinceSync(p) || !!(unsent && unsent.has(p)) || !!(s.boxedHere && s.boxedHere(p)), boxed: (p) => !!(s.boxedHere && s.boxedHere(p)), heldBack: (p) => !!(s.heldBackHere && s.heldBackHere(p)), synced: (p) => !!(s.syncedHere && s.syncedHere(p)), base: s.syncedText ? (p) => s.syncedText(p) : null, own: () => (s.branchOwnPaths ? s.branchOwnPaths() : null), atTip: ((quilt && quilt.atTip) || []).includes(s.squareBranchKey ? s.squareBranchKey() : s.branchKey()) },
         skip: (p) => !s.syncable(p),
         skipDir: s.ignoredDir ? (p) => s.ignoredDir(p) : null,
         record: path.join(s.stateDir || path.join(s.root, '.quilt'), 'block.json'),
@@ -371,6 +383,7 @@ export class SquareFollower {
         onEdits: s.squareEdits ? (list, doc, held) => { if (this.here === here) s.squareEdits(list, doc, held) } : null
       })
       if (this.here !== here) { await block.close().catch(() => {}); return }
+      if (empty) s.joinedEmpty = false
       here.block = block
       here.opening = false
       if (s.followSquareDoc) s.followSquareDoc(block.doc)

package/src/session.js

@@ -592,6 +592,11 @@ export class Session extends EventEmitter {
     this.loadWebhook()
     this.loadOnMention()
     const hadState = this.loadState()
+    // A folder never synced and empty as the session starts: in a session that is a layout-3 quilt already,
+    // whatever it gets before its block opens is the read-only branch document's older copy, never its
+    // member's edits (session-follow.js openHere; 2026-11-01). Cleared by a first word of the quilt that is
+    // not layout 3, and once the block opens.
+    this.joinedEmpty = !hadState && !walk(this.root, this.ig).some((rel) => this.syncable(rel))
     // Restarted while the folder follows its square: its .git is set aside (session-follow.js) and stays so; its branch is the note's.
     this.gitAside = hasGitDir(this.root) ? null : gitAsideOf(this.root)
     if (hadState) this.loadClaims()
@@ -638,6 +643,7 @@ export class Session extends EventEmitter {
     // Seam (Seam's plans/quilt-source-control/16): the relay says when the session is a quilt, and which.
     this.conn.on('quilt', (q) => {
       this.quilt = q
+      if (!(q && q.layout === 3)) this.joinedEmpty = false
       this.emit('quilt', q)
       // At layout 3 this folder follows its branch's square by itself (session-follow.js).
       if (!this.squareFollower) this.squareFollower = new SquareFollower(this)