@doubling/compound-sync 1.5.0 → 1.6.1

package/files.js

@@ -39,6 +39,7 @@ import {
   computeContentHash,
   toBytes,
 } from './storage-helpers.js';
+import { planFolderChain, splitPath } from './folder-chain.js';
 
 // Re-export pure helpers so callers (and existing tests) can import
 // either from here or directly from storage-helpers.js.
@@ -92,11 +93,168 @@ export async function readBlobAsText({ storage, orgId, fileId, ext }) {
   return buf.toString('utf-8');
 }
 
+// ---- Folder-doc operations ----
+
+// Load all folder docs in this org for the given scope. Used by
+// ensureFolderChainInCloud to find or create folder docs along a
+// file's parent path. The result is small (folder count << file count)
+// so this query is cheap.
+async function loadScopedFolders({ filesRef, scope, teamId, userId }) {
+  let q;
+  if (scope === 'private') {
+    q = query(filesRef,
+      where('type', '==', 'folder'),
+      where('scope', '==', 'private'),
+      where('ownerId', '==', userId));
+  } else if (scope === 'team' && teamId) {
+    q = query(filesRef,
+      where('type', '==', 'folder'),
+      where('scope', '==', 'team'),
+      where('teamId', '==', teamId));
+  } else {
+    return [];
+  }
+  const snap = await getDocs(q);
+  const folders = [];
+  snap.forEach(d => folders.push({ id: d.id, ...d.data() }));
+  return folders;
+}
+
+// Apply a planFolderChain result against Firestore. Creates the
+// planned folder docs (rewriting tempId references to real ids) and
+// applies backfills. Returns the resolved leaf folder id (or null if
+// the input plan had no segments).
+async function applyFolderChainPlan({ filesRef, plan, now }) {
+  const tempToReal = new Map();
+  for (const create of plan.creates) {
+    const newRef = doc(filesRef);
+    const docData = {
+      ...create.doc,
+      parentId: tempToReal.get(create.doc.parentId) || create.doc.parentId,
+      createdAt: now,
+      updatedAt: now,
+    };
+    await setDoc(newRef, docData);
+    tempToReal.set(create.tempId, newRef.id);
+  }
+  for (const bf of plan.backfills) {
+    await updateDoc(doc(filesRef, bf.id), { path: bf.path, updatedAt: now });
+  }
+  if (plan.leafId == null) return null;
+  return tempToReal.get(plan.leafId) || plan.leafId;
+}
+
+/**
+ * Ensure folder docs exist for every segment of `docPath` and return
+ * the id of the leaf folder. Idempotent: existing folder docs are
+ * reused; missing ones are created; folder docs missing the `path`
+ * field are backfilled.
+ *
+ * `docPath` is the FULL slash-joined path of the folder itself (NOT a
+ * file path). Pass `'A/B'` to ensure both `A` and `A/B` exist; the
+ * returned id is for `A/B`.
+ *
+ * Returns null if `docPath` is empty (root).
+ */
+export async function ensureFolderChainInCloud({
+  filesRef,
+  scope,
+  teamId,
+  userId,
+  docPath,
+  now = new Date().toISOString(),
+}) {
+  if (scope === 'shared-with-me' || scope === 'shared-by-me') return null;
+  const segments = splitPath(docPath);
+  if (segments.length === 0) return null;
+
+  const existingFolders = await loadScopedFolders({ filesRef, scope, teamId, userId });
+  const plan = planFolderChain({
+    existingFolders,
+    segments,
+    scope,
+    teamId,
+    ownerId: scope === 'private' ? userId : null,
+  });
+  return applyFolderChainPlan({ filesRef, plan, now });
+}
+
+/**
+ * Find or create the folder doc at `docPath`. Convenience wrapper
+ * around ensureFolderChainInCloud for callers that want to upsert a
+ * folder explicitly (e.g., chokidar `addDir` events).
+ *
+ * Returns:
+ *   { action: 'skipped',        reason: 'shared-scope' }
+ *   { action: 'ensured',        folderId }
+ */
+export async function pushFolderToCloud({
+  filesRef,
+  scope,
+  teamId,
+  userId,
+  docPath,
+  now = new Date().toISOString(),
+}) {
+  if (scope === 'shared-with-me' || scope === 'shared-by-me') {
+    return { action: 'skipped', reason: 'shared-scope' };
+  }
+  const folderId = await ensureFolderChainInCloud({
+    filesRef, scope, teamId, userId, docPath, now,
+  });
+  return { action: 'ensured', folderId };
+}
+
+/**
+ * Delete the folder doc at `docPath` if it exists. Does NOT cascade
+ * to children (the sync daemon's `unlinkDir` event fires after its
+ * children's `unlink` events have already cleaned up child docs, so
+ * by the time we reach the folder it should be empty).
+ *
+ * Returns:
+ *   { action: 'skipped',   reason: 'shared-scope' }
+ *   { action: 'not-found' }
+ *   { action: 'deleted',   folderId }
+ */
+export async function deleteFolderFromCloud({
+  filesRef,
+  scope,
+  teamId,
+  userId,
+  docPath,
+}) {
+  if (scope === 'shared-with-me' || scope === 'shared-by-me') {
+    return { action: 'skipped', reason: 'shared-scope' };
+  }
+  let q;
+  if (scope === 'private') {
+    q = query(filesRef,
+      where('type', '==', 'folder'),
+      where('scope', '==', 'private'),
+      where('ownerId', '==', userId),
+      where('path', '==', docPath));
+  } else if (scope === 'team' && teamId) {
+    q = query(filesRef,
+      where('type', '==', 'folder'),
+      where('scope', '==', 'team'),
+      where('teamId', '==', teamId),
+      where('path', '==', docPath));
+  } else {
+    return { action: 'not-found' };
+  }
+  const snap = await getDocs(q);
+  if (snap.empty) return { action: 'not-found' };
+  const docSnap = snap.docs[0];
+  await deleteDoc(docSnap.ref);
+  return { action: 'deleted', folderId: docSnap.id };
+}
+
 // ---- High-level coordinator ----
 
 /**
- * Push a file's content to the cloud: upsert the Firestore metadata
- * doc and upload the blob.
+ * Push a file's content to the cloud: ensure the parent folder chain
+ * exists, upsert the Firestore metadata doc (with canonical fields
+ * including `type: 'file'`, `name`, `parentId`), and upload the blob.
  *
  * Args:
  *   - data: the file's content. String, Buffer, or Uint8Array.
@@ -148,12 +306,32 @@ export async function pushFileToCloud({
   const ext = extFromPath(docPath);
   const contentHash = computeContentHash(data);
   const size = contentByteSize(data);
+  const parts = splitPath(docPath);
+  const fileName = parts[parts.length - 1] || docPath;
+  // Parent folder docs must exist before we write the file doc so the
+  // file's `parentId` is a real folder id. ensureFolderChainInCloud
+  // is idempotent (existing folder docs are reused; missing ones are
+  // created with the canonical shape including `path`).
+  const parentFolderPath = parts.slice(0, -1).join('/');
+  const parentId = parentFolderPath
+    ? await ensureFolderChainInCloud({
+        filesRef,
+        scope,
+        teamId,
+        userId,
+        docPath: parentFolderPath,
+        now,
+      })
+    : null;
 
   if (!snapshot || snapshot.empty) {
     const newDocRef = doc(filesRef);
     const fileId = newDocRef.id;
     const resolvedMime = mimeType || 'text/markdown';
     const fileData = {
+      type: 'file',
+      name: fileName,
+      parentId,
       path: docPath,
       createdAt: now,
       updatedAt: now,
@@ -178,11 +356,17 @@ export async function pushFileToCloud({
 
   const docSnap = snapshot.docs[0];
   const existing = docSnap.data();
-  if (existing.contentHash === contentHash) {
+  if (existing.contentHash === contentHash
+      && existing.type === 'file'
+      && existing.name === fileName
+      && (existing.parentId == null ? null : existing.parentId) === parentId) {
     return { action: 'noop', fileId: docSnap.id };
   }
   const resolvedMime = mimeType || existing.mimeType || 'text/markdown';
   await updateDoc(docSnap.ref, {
+    type: 'file',
+    name: fileName,
+    parentId,
     updatedAt: now,
     storagePath: storagePathFor(orgId, docSnap.id, ext),
     contentHash,

package/folder-chain.js

@@ -0,0 +1,97 @@
+// Pure planner for folder-doc chains. Given a target path and the set
+// of folder docs that already exist in an org+scope, computes which
+// folder docs would need to be created so that every segment along
+// the path corresponds to a real folder doc with the canonical shape.
+//
+// Used by:
+//   - sync/files.js (server-side): before writing a file doc, walk
+//     its parent path and ensure folder docs exist. Returns the leaf
+//     folder's id (or null for root) so the caller can set
+//     `parentId` on the file doc.
+//   - sync/sync.js: when a directory appears locally, run the
+//     planner with `segments` set to the dir's path and apply.
+//
+// Pure: no I/O. Tests exercise it with synthetic inputs.
+
+export function splitPath(p) {
+  if (!p) return [];
+  return p.split('/').filter(Boolean);
+}
+
+function matchesScope(folder, { scope, teamId, ownerId }) {
+  if (folder.scope !== scope) return false;
+  const folderTeam = folder.teamId == null ? null : folder.teamId;
+  const wantTeam = teamId == null ? null : teamId;
+  if (folderTeam !== wantTeam) return false;
+  const folderOwner = folder.ownerId == null ? null : folder.ownerId;
+  const wantOwner = ownerId == null ? null : ownerId;
+  if (folderOwner !== wantOwner) return false;
+  return true;
+}
+
+// Plan the folder chain. Inputs:
+//   - existingFolders: array of folder docs from the org's files
+//     collection. Each has { id, type:'folder', name, parentId, path?,
+//     scope, teamId, ownerId, ... }.
+//   - segments: ordered path parts (no filename). For "A/B/file.md"
+//     the caller passes ['A', 'B']. For a folder doc itself at path
+//     "A/B", the caller passes ['A', 'B'].
+//   - scope, teamId, ownerId: the scope shape the folders must match.
+//
+// Returns:
+//   - creates: array of { tempId, doc } describing folder docs that
+//     would need to be created. Order is root-first; later items may
+//     reference earlier items' tempIds in their parentId field.
+//   - backfills: existing folder docs missing a `path` field, with
+//     the path they should be set to.
+//   - leafId: id of the leaf folder (the deepest segment), either a
+//     real id (if it existed) or a tempId (if planned for creation).
+//     null if `segments` is empty.
+export function planFolderChain({ existingFolders, segments, scope, teamId, ownerId }) {
+  const creates = [];
+  const backfills = [];
+
+  if (!segments || segments.length === 0) {
+    return { creates, backfills, leafId: null };
+  }
+
+  let parentId = null;
+  let pathSoFar = '';
+
+  for (const name of segments) {
+    pathSoFar = pathSoFar ? `${pathSoFar}/${name}` : name;
+
+    const existing = (existingFolders || []).find(f =>
+      f && f.type === 'folder'
+      && f.name === name
+      && (f.parentId == null ? null : f.parentId) === parentId
+      && matchesScope(f, { scope, teamId, ownerId })
+    );
+
+    if (existing) {
+      if (existing.path !== pathSoFar) {
+        backfills.push({ id: existing.id, path: pathSoFar });
+      }
+      parentId = existing.id;
+      continue;
+    }
+
+    const tempId = `__plan_folder_${creates.length}`;
+    creates.push({
+      tempId,
+      doc: {
+        type: 'folder',
+        name,
+        parentId,
+        path: pathSoFar,
+        scope,
+        teamId: scope === 'team' ? (teamId == null ? null : teamId) : null,
+        ownerId: scope === 'private' ? (ownerId == null ? null : ownerId) : null,
+        sharedWith: [],
+      },
+    });
+    parentId = tempId;
+  }
+
+  return { creates, backfills, leafId: parentId };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doubling/compound-sync",
-  "version": "1.5.0",
+  "version": "1.6.1",
   "description": "Bidirectional sync between Compound and local markdown files",
   "type": "module",
   "bin": {
@@ -11,12 +11,14 @@
     "config.js",
     "paths.js",
     "files.js",
+    "folder-chain.js",
     "storage-helpers.js",
+    "team-registry.js",
     "README.md"
   ],
   "scripts": {
     "sync": "node sync.js",
-    "test:unit": "node --test config.test.js paths.test.js storage-helpers.test.js",
+    "test:unit": "node --test config.test.js paths.test.js storage-helpers.test.js folder-chain.test.js team-registry.test.js",
     "test:integration": "firebase emulators:exec --only firestore,storage 'node --test files.test.js'",
     "test": "npm run test:unit && npm run test:integration"
   },

package/storage-helpers.js

@@ -80,6 +80,16 @@ const EXT_TO_MIME = {
   webm: 'video/webm',
   mov: 'video/quicktime',
   zip: 'application/zip',
+  // Office Open XML (modern Office). The full type strings are
+  // mandatory: tools that dispatch by mime (Excel, third-party readers)
+  // ignore alternative spellings.
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  // Legacy Office formats (pre-2007 binary containers).
+  xls: 'application/vnd.ms-excel',
+  doc: 'application/msword',
+  ppt: 'application/vnd.ms-powerpoint',
 };
 
 export function mimeTypeFromExt(ext) {

package/sync.js

@@ -35,6 +35,8 @@ import { fileURLToPath } from 'url';
 import {
   pushFileToCloud,
   deleteFileFromCloud,
+  pushFolderToCloud,
+  deleteFolderFromCloud,
   readBlob,
   readBlobAsText,
   extFromPath,
@@ -52,6 +54,7 @@ import {
   SHARED_WITH_ME_FOLDER,
   SHARED_BY_ME_FOLDER,
 } from './paths.js';
+import { TeamRegistry } from './team-registry.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -566,25 +569,34 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
   const LOCAL_PATH = expandHome(rawLocalPath);
   const filesRef = collection(db, `orgs/${orgId}/files`);
 
-  const teams = new Map();
-  const teamIdsByName = new Map();
   const lastKnownUpdate = new Map();
   const suppressLocal = new Set();
-
-  async function loadTeams() {
-    const snapshot = await getDocs(collection(db, `orgs/${orgId}/teams`));
-    snapshot.forEach(d => {
-      const data = d.data();
-      teams.set(d.id, data);
-      teamIdsByName.set(data.name, d.id);
-    });
+  // Per-team Firestore-listener unsubscribe handles, keyed by teamId.
+  // The TeamRegistry's onSetup populates this; onTeardown calls and
+  // drops the entry so a removed teamspace stops pulling files.
+  const teamUnsubscribers = new Map();
+  // Hoisted forward-decl: setupTeam closes over handleFirestoreChange,
+  // which is defined later in this function. Wired below.
+  let setupTeam = () => {};
+  function teardownTeam(teamId, teamData) {
+    const unsub = teamUnsubscribers.get(teamId);
+    if (unsub) {
+      try { unsub(); } catch (e) { /* ignore */ }
+      teamUnsubscribers.delete(teamId);
+      const folder = teamData && teamData.name ? teamFolderName(teamData.name) : teamId;
+      console.log(`  [${orgId}]   Stopped listening: ${folder}`);
+    }
   }
-
-  await loadTeams();
+  const teamRegistry = new TeamRegistry({
+    onSetup: (teamId, teamData) => setupTeam(teamId, teamData),
+    onTeardown: teardownTeam,
+  });
+  // scopeFromLocalPath expects a Map<teamName, teamId>; the registry
+  // exposes one matching that shape.
+  const teamIdsByName = teamRegistry.teamIdsByName;
 
   console.log('');
   console.log(`  [${orgId}] Local: ${LOCAL_PATH}`);
-  console.log(`  [${orgId}] Teams: ${[...teams.values()].map(t => t.name).join(', ') || 'none'}`);
 
   function ensureDir(filePath) {
     const dir = path.dirname(filePath);
@@ -619,6 +631,8 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
     }
   }
 
+  // Static (user-level) folders. Team folders are created per-team by
+  // setupTeam below as soon as the registry sees each teamspace.
   function ensureFolderStructure() {
     const privatePath = path.join(LOCAL_PATH, PRIVATE_FOLDER);
     if (!fs.existsSync(privatePath)) fs.mkdirSync(privatePath, { recursive: true });
@@ -628,11 +642,6 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
 
     const sharedByMePath = path.join(LOCAL_PATH, SHARED_BY_ME_FOLDER);
     if (!fs.existsSync(sharedByMePath)) fs.mkdirSync(sharedByMePath, { recursive: true });
-
-    for (const [, teamData] of teams) {
-      const teamPath = path.join(LOCAL_PATH, teamFolderName(teamData.name));
-      if (!fs.existsSync(teamPath)) fs.mkdirSync(teamPath, { recursive: true });
-    }
   }
 
   ensureFolderStructure();
@@ -644,9 +653,26 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
 
     const localFilePath = getLocalPath(data);
     const trackingKey = `${data.scope || 'team'}:${docPath}`;
+    const isFolder = data.type === 'folder';
 
     if (change.type === 'removed') {
-      if (fs.existsSync(localFilePath)) {
+      if (isFolder) {
+        // Best-effort directory removal. The daemon's own file-delete
+        // events should have cleared all children by the time we get
+        // here; if not, rmdirSync throws ENOTEMPTY and we keep the
+        // directory rather than risk losing data the user hasn't seen.
+        try {
+          suppressLocal.add(localFilePath);
+          fs.rmdirSync(localFilePath);
+          console.log(`  [${orgId}] [firestore → local] RMDIR ${docPath}`);
+          setTimeout(() => suppressLocal.delete(localFilePath), 1000);
+        } catch (err) {
+          suppressLocal.delete(localFilePath);
+          if (err.code !== 'ENOENT' && err.code !== 'ENOTEMPTY') {
+            console.error(`  [${orgId}] [firestore → local] RMDIR ${docPath} failed: ${err.message}`);
+          }
+        }
+      } else if (fs.existsSync(localFilePath)) {
         console.log(`  [${orgId}] [firestore → local] DELETE ${docPath}`);
         suppressLocal.add(localFilePath);
         fs.unlinkSync(localFilePath);
@@ -660,6 +686,19 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
     const lastKnown = lastKnownUpdate.get(trackingKey);
     if (lastKnown && lastKnown >= remoteUpdated) return;
 
+    if (isFolder) {
+      // Folder docs mirror to a local directory. No blob, no content
+      // comparison; if the directory doesn't exist yet, create it.
+      if (!fs.existsSync(localFilePath)) {
+        suppressLocal.add(localFilePath);
+        fs.mkdirSync(localFilePath, { recursive: true });
+        console.log(`  [${orgId}] [firestore → local] MKDIR ${docPath}`);
+        setTimeout(() => suppressLocal.delete(localFilePath), 1000);
+      }
+      lastKnownUpdate.set(trackingKey, remoteUpdated);
+      return;
+    }
+
     if (fs.existsSync(localFilePath)) {
       const localMtime = fs.statSync(localFilePath).mtime.toISOString();
       if (localMtime > remoteUpdated) return;
@@ -692,21 +731,58 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
     setTimeout(() => suppressLocal.delete(localFilePath), 1000);
   }
 
-  function startFirestoreListeners() {
-    console.log(`  [${orgId}] Starting Firestore listeners...`);
+  // Set up per-team resources: mkdir the local folder, register the
+  // Firestore listener for that team's files. Wired into the
+  // TeamRegistry; called once per teamspace as it appears.
+  setupTeam = (teamId, teamData) => {
+    const teamFolder = teamFolderName(teamData.name);
+    const teamPath = path.join(LOCAL_PATH, teamFolder);
+    if (!fs.existsSync(teamPath)) fs.mkdirSync(teamPath, { recursive: true });
+
+    const q = query(filesRef, where('scope', '==', 'team'), where('teamId', '==', teamId));
+    const unsubscribe = onSnapshot(q, snapshot => {
+      snapshot.docChanges().forEach(change => {
+        handleFirestoreChange(change, data =>
+          path.join(LOCAL_PATH, teamFolder, data.path),
+        ).catch(err => console.error(`  [${orgId}] Firestore change handler error:`, err && err.message));
+      });
+    }, err => console.error(`  [${orgId}] Team "${teamFolder}" listener error:`, err));
 
-    for (const [teamId, teamData] of teams) {
-      const teamFolder = teamFolderName(teamData.name);
-      const q = query(filesRef, where('scope', '==', 'team'), where('teamId', '==', teamId));
-      onSnapshot(q, snapshot => {
-        snapshot.docChanges().forEach(change => {
-          handleFirestoreChange(change, data =>
-            path.join(LOCAL_PATH, teamFolder, data.path),
-          ).catch(err => console.error(`  [${orgId}] Firestore change handler error:`, err && err.message));
+    teamUnsubscribers.set(teamId, unsubscribe);
+    console.log(`  [${orgId}]   Listening: ${teamFolder}`);
+  };
+
+  // Live listener on the teams collection. Initial snapshot bootstraps
+  // the known teamspaces; subsequent changes pick up new/renamed/
+  // removed teamspaces without restarting the daemon. We await the
+  // first snapshot so the local watcher sees a populated teamIdsByName
+  // before it tries to route any addDir/add events.
+  await new Promise((resolve, reject) => {
+    let firstSnapshotResolved = false;
+    onSnapshot(collection(db, `orgs/${orgId}/teams`), (snapshot) => {
+      snapshot.docChanges().forEach((change) => {
+        teamRegistry.applyChange({
+          type: change.type,
+          id: change.doc.id,
+          data: change.doc.data(),
         });
-      }, err => console.error(`  [${orgId}] Team "${teamFolder}" listener error:`, err));
-      console.log(`  [${orgId}]   Listening: ${teamFolder}`);
-    }
+      });
+      if (!firstSnapshotResolved) {
+        firstSnapshotResolved = true;
+        console.log(`  [${orgId}] Teams: ${teamRegistry.names().join(', ') || 'none'}`);
+        resolve();
+      }
+    }, (err) => {
+      console.error(`  [${orgId}] Teams listener error:`, err);
+      if (!firstSnapshotResolved) {
+        firstSnapshotResolved = true;
+        reject(err);
+      }
+    });
+  });
+
+  function startFirestoreListeners() {
+    console.log(`  [${orgId}] Starting Firestore listeners...`);
 
     if (USER_ID) {
       const privateQ = query(filesRef, where('scope', '==', 'private'), where('ownerId', '==', USER_ID));
@@ -791,6 +867,64 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
     }
   }
 
+  // Determine whether a local path corresponds to a syncable directory.
+  // Excludes the scope-root directories themselves (Private, Shared
+  // with Me, Shared by Me, and the per-team roots) since those are
+  // managed by ensureFolderStructure, not the user.
+  function isSyncableLocalDir(rel) {
+    if (!rel) return false;
+    if (rel === PRIVATE_FOLDER || rel === SHARED_WITH_ME_FOLDER || rel === SHARED_BY_ME_FOLDER) {
+      return false;
+    }
+    if (rel.startsWith(SHARED_WITH_ME_FOLDER + path.sep)) return false;
+    if (rel.startsWith(SHARED_BY_ME_FOLDER + path.sep)) return false;
+    const parts = rel.split(path.sep);
+    // A bare team root (e.g. "Engineering Teamspace") corresponds to
+    // the scope root, not a subdirectory. Skip these.
+    if (parts.length === 1 && parts[0].endsWith(' Teamspace')) return false;
+    return true;
+  }
+
+  async function pushDirToFirestore(dirPath) {
+    const { scope, teamId, docPath } = scopeFromLocalPath(dirPath, LOCAL_PATH, teamIdsByName);
+    if (!docPath) return; // scope root
+    const trackingKey = `${scope}:${docPath}`;
+    const now = new Date().toISOString();
+    lastKnownUpdate.set(trackingKey, now);
+
+    const result = await pushFolderToCloud({
+      filesRef,
+      scope,
+      teamId,
+      userId: USER_ID,
+      docPath,
+      now,
+    });
+
+    if (result.action === 'ensured' && result.folderId) {
+      console.log(`  [${orgId}] [local → firestore] FOLDER ${docPath} (${scope})`);
+    }
+  }
+
+  async function deleteDirFromFirestore(dirPath) {
+    const { scope, teamId, docPath } = scopeFromLocalPath(dirPath, LOCAL_PATH, teamIdsByName);
+    if (!docPath) return;
+    const trackingKey = `${scope}:${docPath}`;
+    lastKnownUpdate.delete(trackingKey);
+
+    const result = await deleteFolderFromCloud({
+      filesRef,
+      scope,
+      teamId,
+      userId: USER_ID,
+      docPath,
+    });
+
+    if (result.action === 'deleted') {
+      console.log(`  [${orgId}] [local → firestore] RMFOLDER ${docPath} (${scope})`);
+    }
+  }
+
   function handleLocalChange(filePath) {
     if (suppressLocal.has(filePath)) return;
 
@@ -823,6 +957,24 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
     );
   }
 
+  function handleLocalDirAdded(dirPath) {
+    if (suppressLocal.has(dirPath)) return;
+    const rel = path.relative(LOCAL_PATH, dirPath);
+    if (!isSyncableLocalDir(rel)) return;
+    pushDirToFirestore(dirPath).catch(err =>
+      console.error(`  [${orgId}] Folder push error for ${rel}: ${err.message}`)
+    );
+  }
+
+  function handleLocalDirRemoved(dirPath) {
+    if (suppressLocal.has(dirPath)) return;
+    const rel = path.relative(LOCAL_PATH, dirPath);
+    if (!isSyncableLocalDir(rel)) return;
+    deleteDirFromFirestore(dirPath).catch(err =>
+      console.error(`  [${orgId}] Folder delete error for ${rel}: ${err.message}`)
+    );
+  }
+
   function startLocalWatcher() {
     console.log(`  [${orgId}] Watching local files...`);
 
@@ -849,6 +1001,8 @@ async function setupOrgSync({ orgId, localPath: rawLocalPath }) {
       if (suppressLocal.has(filePath)) return;
       deleteFromFirestore(filePath).catch(err => console.error(`  [${orgId}] Delete error: ${err.message}`));
     });
+    watcher.on('addDir', dirPath => handleLocalDirAdded(dirPath));
+    watcher.on('unlinkDir', dirPath => handleLocalDirRemoved(dirPath));
 
     watcher.on('ready', () => console.log(`  [${orgId}] Local watcher ready.`));
   }

package/team-registry.js

@@ -0,0 +1,94 @@
+// Pure state machine for tracking which teamspaces the sync daemon
+// is currently watching. The daemon used to enumerate teams once at
+// startup and statically register a Firestore listener for each; this
+// missed any teamspaces created later (e.g. via the web's "+ New
+// Teamspace" button) until the daemon was restarted.
+//
+// TeamRegistry owns the in-memory map of teamId -> teamData and
+// dispatches setup/teardown callbacks when the desired team set
+// changes. The actual side effects (mkdir, onSnapshot, unsubscribe)
+// live in the caller and are passed in as `onSetup` / `onTeardown`.
+// This keeps the dispatch logic testable without mocking Firestore.
+//
+// Usage:
+//   const registry = new TeamRegistry({
+//     onSetup: (teamId, teamData) => { ... },
+//     onTeardown: (teamId, teamData) => { ... },
+//   });
+//   // For each docChange from onSnapshot on the teams collection:
+//   registry.applyChange({ type: 'added', id, data });
+
+export class TeamRegistry {
+  constructor({ onSetup, onTeardown }) {
+    this.teams = new Map(); // teamId -> teamData
+    this.teamIdsByName = new Map(); // teamName -> teamId
+    this.onSetup = onSetup;
+    this.onTeardown = onTeardown;
+  }
+
+  // Idempotently register a team. Safe to call with the same team
+  // multiple times; only the first call triggers onSetup.
+  add(teamId, teamData) {
+    if (this.teams.has(teamId)) return false;
+    this.teams.set(teamId, teamData);
+    if (teamData && teamData.name) {
+      this.teamIdsByName.set(teamData.name, teamId);
+    }
+    this.onSetup(teamId, teamData);
+    return true;
+  }
+
+  // Update a team's metadata. If the team's name changed, treat as a
+  // rename: teardown the old listener, register a new one (which
+  // creates a new local folder under the new name). The old folder
+  // is intentionally NOT renamed or removed; the user can clean it
+  // up manually. This is conservative; a rename-aware implementation
+  // is a follow-up.
+  modify(teamId, teamData) {
+    const prev = this.teams.get(teamId);
+    if (!prev) {
+      // Treat modify-of-unknown as an add. Firestore emits both
+      // 'added' and 'modified' for the same doc under certain
+      // listener-restart scenarios, so we want this path resilient.
+      return this.add(teamId, teamData);
+    }
+    this.teams.set(teamId, teamData);
+    const renamed = prev.name !== (teamData && teamData.name);
+    if (renamed) {
+      if (prev.name) this.teamIdsByName.delete(prev.name);
+      if (teamData && teamData.name) {
+        this.teamIdsByName.set(teamData.name, teamId);
+      }
+      this.onTeardown(teamId, prev);
+      this.onSetup(teamId, teamData);
+    }
+    return renamed;
+  }
+
+  // Remove a team (e.g., user lost membership). Tears down the
+  // listener; leaves any local folder alone.
+  remove(teamId) {
+    const prev = this.teams.get(teamId);
+    if (!prev) return false;
+    this.teams.delete(teamId);
+    if (prev.name) this.teamIdsByName.delete(prev.name);
+    this.onTeardown(teamId, prev);
+    return true;
+  }
+
+  // Convenience: dispatch a Firestore docChange into add/modify/remove.
+  applyChange({ type, id, data }) {
+    if (type === 'added') return this.add(id, data);
+    if (type === 'modified') return this.modify(id, data);
+    if (type === 'removed') return this.remove(id);
+    return false;
+  }
+
+  // Read-only accessors for the daemon's existing call sites.
+  has(teamId) { return this.teams.has(teamId); }
+  get(teamId) { return this.teams.get(teamId); }
+  getIdByName(teamName) { return this.teamIdsByName.get(teamName); }
+  size() { return this.teams.size; }
+  entries() { return this.teams.entries(); }
+  names() { return [...this.teams.values()].map(t => t.name).filter(Boolean); }
+}