jowork 0.2.5 → 0.3.0

package/dist/{chunk-HUHDL7WV.js → chunk-QGHJ45PL.js}

@@ -2,40 +2,42 @@ import {
   linkAllUnprocessed,
   syncGitLab,
   syncLinear
-} from "./chunk-YJWTKFWX.js";
+} from "./chunk-HENAABEL.js";
+import {
+  syncGitHub
+} from "./chunk-63AMINQC.js";
+import {
+  GitManager
+} from "./chunk-EYP6WMFF.js";
 import {
   DbManager
-} from "./chunk-XAEGXSEO.js";
+} from "./chunk-74AHY7X6.js";
 import {
   listCredentials,
   loadCredential
-} from "./chunk-XLYRHKG6.js";
+} from "./chunk-54SD5GBF.js";
 import {
   dbPath,
   fileRepoDir
-} from "./chunk-ROIINI33.js";
+} from "./chunk-4PIT2GZ4.js";
 import {
-  syncGitHub
-} from "./chunk-LS2AJM5A.js";
-import {
-  contentHash,
-  formatAnalytics,
-  formatMessages,
   syncFeishu,
   syncFeishuApprovals,
   syncFeishuDocs,
+  syncFeishuLinks,
   syncFeishuMeetings
-} from "./chunk-QMOFQX7X.js";
-import {
-  createId
-} from "./chunk-JE6TOU7W.js";
+} from "./chunk-DQW74UCN.js";
 import {
-  GitManager
-} from "./chunk-L5ZR7TSK.js";
+  formatAnalytics,
+  formatMessages
+} from "./chunk-RO3KK5RC.js";
 import {
   logError,
   logInfo
 } from "./chunk-MYDK7MWB.js";
+import {
+  SyncContext
+} from "./chunk-OXWWOKC7.js";
 
 // src/commands/sync.ts
 import { existsSync as existsSync2 } from "fs";
@@ -46,7 +48,7 @@ var defaultLogger = {
   warn: (msg, ctx) => logError("sync", msg, ctx),
   error: (msg, ctx) => logError("sync", msg, ctx)
 };
-async function syncPostHog(sqlite, data, logger = defaultLogger, fileWriter) {
+async function syncPostHog(ctx, data, logger = defaultLogger) {
   const { apiKey, host, projectId: rawProjectId } = data;
   if (!apiKey) throw new Error("Missing PostHog API key");
   const baseUrl = host || "https://app.posthog.com";
@@ -55,123 +57,139 @@ async function syncPostHog(sqlite, data, logger = defaultLogger, fileWriter) {
     Authorization: `Bearer ${apiKey}`,
     "Content-Type": "application/json"
   };
-  let events = 0, insights = 0, newObjects = 0;
-  const checkExists = sqlite.prepare("SELECT id FROM objects WHERE uri = ?");
-  const insertObj = sqlite.prepare(`
-    INSERT INTO objects (id, source, source_type, uri, title, summary, tags, content_hash, last_synced_at, created_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-  const insertBody = sqlite.prepare(`
-    INSERT OR REPLACE INTO object_bodies (object_id, content, content_type, fetched_at)
-    VALUES (?, ?, ?, ?)
-  `);
-  const insertFts = sqlite.prepare(`
-    INSERT INTO objects_fts(rowid, title, summary, tags, source, source_type, body_excerpt)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-  `);
-  const getRowid = sqlite.prepare("SELECT rowid FROM objects WHERE id = ?");
+  let events = 0, insights = 0, newObjects = 0, updatedObjects = 0;
   try {
-    const insightsRes = await fetch(`${baseUrl}/api/projects/${projectId}/insights/?limit=50`, { headers });
-    if (insightsRes.ok) {
-      const insightsData = await insightsRes.json();
-      const batch = sqlite.transaction((items) => {
-        for (const insight of items) {
-          const uri = `posthog://insight/${insight.id}`;
-          if (checkExists.get(uri)) continue;
-          const now = Date.now();
-          const id = createId("obj");
-          const summary = insight.description || `Insight: ${insight.name}`;
-          const tags = JSON.stringify(["posthog", "insight", ...Object.keys(insight.filters).slice(0, 3)]);
-          const body = JSON.stringify({
-            name: insight.name,
-            description: insight.description,
-            filters: insight.filters,
-            lastRefresh: insight.last_refresh
-          }, null, 2);
-          insertObj.run(id, "posthog", "insight", uri, insight.name, summary, tags, contentHash(body), now, now);
-          insertBody.run(id, body, "application/json", now);
-          try {
-            const rowid = getRowid.get(id);
-            if (rowid) {
-              const excerpt = body.length > 500 ? body.slice(0, 500) : body;
-              insertFts.run(rowid.rowid, insight.name ?? "", summary ?? "", tags, "posthog", "insight", excerpt);
-            }
-          } catch {
-          }
-          if (fileWriter) {
-            try {
-              const fileContent = formatAnalytics({
-                name: insight.name,
-                description: insight.description,
-                filters: insight.filters,
-                lastRefresh: insight.last_refresh
-              });
-              const filePath = fileWriter.writeObject("posthog", "insight", {
-                id,
-                title: insight.name
-              }, fileContent);
-              sqlite.prepare("UPDATE objects SET file_path = ? WHERE id = ?").run(filePath, id);
-            } catch {
-            }
-          }
-          insights++;
-          newObjects++;
-        }
-      });
-      batch(insightsData.results ?? []);
+    let insightsUrl = `${baseUrl}/api/projects/${projectId}/insights/?limit=100`;
+    const allInsights = [];
+    while (insightsUrl) {
+      const insightsRes = await fetch(insightsUrl, { headers });
+      if (!insightsRes.ok) {
+        logger.warn(`Failed to fetch insights: ${insightsRes.status}`);
+        break;
+      }
+      const page = await insightsRes.json();
+      allInsights.push(...page.results ?? []);
+      insightsUrl = page.next;
+      if (insightsUrl) await new Promise((r) => setTimeout(r, 200));
+    }
+    if (allInsights.length > 0) {
+      const items = [];
+      for (const insight of allInsights) {
+        const uri = `posthog://insight/${insight.id}`;
+        const summary = insight.description || `Insight: ${insight.name}`;
+        const body = JSON.stringify({
+          name: insight.name,
+          description: insight.description,
+          filters: insight.filters,
+          lastRefresh: insight.last_refresh
+        }, null, 2);
+        const fileContent = formatAnalytics({
+          name: insight.name,
+          description: insight.description,
+          filters: insight.filters,
+          lastRefresh: insight.last_refresh
+        });
+        items.push({
+          source: "posthog",
+          sourceType: "insight",
+          uri,
+          title: insight.name,
+          summary,
+          tags: ["posthog", "insight", ...Object.keys(insight.filters).slice(0, 3)],
+          content: body,
+          contentType: "application/json",
+          fileContent,
+          fileMeta: { title: insight.name }
+        });
+      }
+      const result = ctx.batchUpsert(items);
+      newObjects += result.inserted;
+      updatedObjects += result.updated;
+      insights += items.length;
       logger.info(`Synced ${insights} insights`);
-    } else {
-      logger.warn(`Failed to fetch insights: ${insightsRes.status}`);
     }
   } catch (err) {
     logger.error(`Insights sync error: ${err}`);
   }
   try {
-    const eventsRes = await fetch(`${baseUrl}/api/projects/${projectId}/event_definitions/?limit=100`, { headers });
-    if (eventsRes.ok) {
-      const eventsData = await eventsRes.json();
-      const batch = sqlite.transaction((items) => {
-        for (const event of items) {
-          const uri = `posthog://event/${event.name}`;
-          if (checkExists.get(uri)) continue;
-          const now = Date.now();
-          const id = createId("obj");
-          const summary = `${event.name}: ${event.description ?? "no description"} (30d volume: ${event.volume_30_day ?? "N/A"})`;
-          const tags = JSON.stringify(["posthog", "event_definition"]);
-          const body = JSON.stringify(event, null, 2);
-          insertObj.run(id, "posthog", "event_definition", uri, event.name, summary, tags, contentHash(body), now, now);
-          insertBody.run(id, body, "application/json", now);
-          try {
-            const rowid = getRowid.get(id);
-            if (rowid) {
-              const excerpt = body.length > 500 ? body.slice(0, 500) : body;
-              insertFts.run(rowid.rowid, event.name ?? "", summary ?? "", tags, "posthog", "event_definition", excerpt);
-            }
-          } catch {
-          }
-          if (fileWriter) {
-            try {
-              const fileContent = formatAnalytics(event);
-              const filePath = fileWriter.writeObject("posthog", "event_definition", {
-                id,
-                title: event.name
-              }, fileContent);
-              sqlite.prepare("UPDATE objects SET file_path = ? WHERE id = ?").run(filePath, id);
-            } catch {
-            }
-          }
-          events++;
-          newObjects++;
-        }
-      });
-      batch(eventsData.results ?? []);
+    let eventsUrl = `${baseUrl}/api/projects/${projectId}/event_definitions/?limit=100`;
+    const allEvents = [];
+    while (eventsUrl) {
+      const eventsRes = await fetch(eventsUrl, { headers });
+      if (!eventsRes.ok) break;
+      const page = await eventsRes.json();
+      allEvents.push(...page.results ?? []);
+      eventsUrl = page.next;
+      if (eventsUrl) await new Promise((r) => setTimeout(r, 200));
+    }
+    if (allEvents.length > 0) {
+      const items = [];
+      for (const event of allEvents) {
+        const uri = `posthog://event/${event.name}`;
+        const summary = `${event.name}: ${event.description ?? "no description"} (30d volume: ${event.volume_30_day ?? "N/A"})`;
+        const body = JSON.stringify(event, null, 2);
+        const fileContent = formatAnalytics(event);
+        items.push({
+          source: "posthog",
+          sourceType: "event_definition",
+          uri,
+          title: event.name,
+          summary,
+          tags: ["posthog", "event_definition"],
+          content: body,
+          contentType: "application/json",
+          fileContent,
+          fileMeta: { title: event.name }
+        });
+      }
+      const result = ctx.batchUpsert(items);
+      newObjects += result.inserted;
+      updatedObjects += result.updated;
+      events += items.length;
       logger.info(`Synced ${events} event definitions`);
     }
   } catch (err) {
     logger.error(`Events sync error: ${err}`);
   }
-  logger.info("PostHog sync complete", { events, insights, newObjects });
-  return { events, insights, newObjects };
+  try {
+    let actionsUrl = `${baseUrl}/api/projects/${projectId}/actions/?limit=100`;
+    while (actionsUrl) {
+      const actionsRes = await fetch(actionsUrl, { headers });
+      if (!actionsRes.ok) break;
+      const page = await actionsRes.json();
+      const items = [];
+      for (const action of page.results ?? []) {
+        const uri = `posthog://action/${action.id}`;
+        const summary = action.description || `Action: ${action.name}`;
+        const body = JSON.stringify(action, null, 2);
+        const fileContent = formatAnalytics(action);
+        items.push({
+          source: "posthog",
+          sourceType: "action",
+          uri,
+          title: action.name,
+          summary,
+          tags: ["posthog", "action"],
+          content: body,
+          contentType: "application/json",
+          createdAt: new Date(action.created_at).getTime(),
+          fileContent,
+          fileMeta: { title: action.name }
+        });
+      }
+      const result = ctx.batchUpsert(items);
+      newObjects += result.inserted;
+      updatedObjects += result.updated;
+      actionsUrl = page.next;
+      if (actionsUrl) await new Promise((r) => setTimeout(r, 200));
+    }
+  } catch (err) {
+    logger.warn(`Actions sync error (non-fatal): ${err}`);
+  }
+  ctx.saveTimestampCursor("posthog:insights");
+  ctx.saveTimestampCursor("posthog:events");
+  logger.info("PostHog sync complete", { events, insights, newObjects, updatedObjects });
+  return { events, insights, newObjects, updatedObjects };
 }
 
 // src/sync/firebase.ts
@@ -180,24 +198,10 @@ var defaultLogger2 = {
   warn: (msg, ctx) => logError("sync", msg, ctx),
   error: (msg, ctx) => logError("sync", msg, ctx)
 };
-async function syncFirebase(sqlite, data, logger = defaultLogger2, fileWriter) {
+async function syncFirebase(ctx, data, logger = defaultLogger2) {
   const { projectId, apiKey } = data;
   if (!projectId) throw new Error("Missing Firebase project ID");
-  let events = 0, newObjects = 0;
-  const checkExists = sqlite.prepare("SELECT id FROM objects WHERE uri = ?");
-  const insertObj = sqlite.prepare(`
-    INSERT INTO objects (id, source, source_type, uri, title, summary, tags, content_hash, last_synced_at, created_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-  const insertBody = sqlite.prepare(`
-    INSERT OR REPLACE INTO object_bodies (object_id, content, content_type, fetched_at)
-    VALUES (?, ?, ?, ?)
-  `);
-  const insertFts = sqlite.prepare(`
-    INSERT INTO objects_fts(rowid, title, summary, tags, source, source_type, body_excerpt)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-  `);
-  const getRowid = sqlite.prepare("SELECT rowid FROM objects WHERE id = ?");
+  let events = 0, newObjects = 0, updatedObjects = 0;
   if (apiKey) {
     try {
       const propertyId = data.propertyId ?? projectId;
@@ -207,51 +211,41 @@ async function syncFirebase(sqlite, data, logger = defaultLogger2, fileWriter) {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({
-            dateRanges: [{ startDate: "7daysAgo", endDate: "today" }],
+            dateRanges: [{ startDate: "30daysAgo", endDate: "today" }],
             dimensions: [{ name: "eventName" }],
-            metrics: [{ name: "eventCount" }],
-            limit: 50
+            metrics: [{ name: "eventCount" }, { name: "totalUsers" }],
+            limit: 500
           })
         }
       );
       if (res.ok) {
         const report = await res.json();
-        const batch = sqlite.transaction((rows) => {
-          for (const row of rows) {
-            const eventName = row.dimensionValues[0]?.value ?? "unknown";
-            const eventCount = parseInt(row.metricValues[0]?.value ?? "0");
-            const uri = `firebase://${projectId}/event/${eventName}`;
-            if (checkExists.get(uri)) continue;
-            const nowMs = Date.now();
-            const id = createId("obj");
-            const summary = `${eventName}: ${eventCount} events (last 7 days)`;
-            const tags = JSON.stringify(["firebase", "analytics", "event"]);
-            const body = JSON.stringify({ eventName, eventCount, period: "7daysAgo..today" }, null, 2);
-            insertObj.run(id, "firebase", "analytics_event", uri, eventName, summary, tags, contentHash(body), nowMs, nowMs);
-            insertBody.run(id, body, "application/json", nowMs);
-            try {
-              const rowid = getRowid.get(id);
-              if (rowid) {
-                insertFts.run(rowid.rowid, eventName ?? "", summary ?? "", tags, "firebase", "analytics_event", body.length > 500 ? body.slice(0, 500) : body);
-              }
-            } catch {
-            }
-            if (fileWriter) {
-              try {
-                const fileContent = formatAnalytics({ eventName, eventCount, period: "7daysAgo..today" });
-                const filePath = fileWriter.writeObject("firebase", "analytics_event", {
-                  id,
-                  title: eventName
-                }, fileContent);
-                sqlite.prepare("UPDATE objects SET file_path = ? WHERE id = ?").run(filePath, id);
-              } catch {
-              }
-            }
-            events++;
-            newObjects++;
-          }
-        });
-        batch(report.rows ?? []);
+        const items = [];
+        for (const row of report.rows ?? []) {
+          const eventName = row.dimensionValues[0]?.value ?? "unknown";
+          const eventCount = parseInt(row.metricValues[0]?.value ?? "0");
+          const totalUsers = parseInt(row.metricValues[1]?.value ?? "0");
+          const uri = `firebase://${projectId}/event/${eventName}`;
+          const summary = `${eventName}: ${eventCount} events, ${totalUsers} users (last 30 days)`;
+          const body = JSON.stringify({ eventName, eventCount, totalUsers, period: "30daysAgo..today" }, null, 2);
+          const fileContent = formatAnalytics({ eventName, eventCount, totalUsers, period: "30daysAgo..today" });
+          items.push({
+            source: "firebase",
+            sourceType: "analytics_event",
+            uri,
+            title: eventName,
+            summary,
+            tags: ["firebase", "analytics", "event"],
+            content: body,
+            contentType: "application/json",
+            fileContent,
+            fileMeta: { title: eventName }
+          });
+        }
+        const result = ctx.batchUpsert(items);
+        newObjects += result.inserted;
+        updatedObjects += result.updated;
+        events += items.length;
       } else {
         logger.warn(`Firebase Analytics API: ${res.status}`);
       }
@@ -261,8 +255,9 @@ async function syncFirebase(sqlite, data, logger = defaultLogger2, fileWriter) {
   } else {
     logger.warn("Firebase sync requires apiKey. Provide via jowork connect firebase --api-key <key>");
   }
-  logger.info("Firebase sync complete", { events, newObjects });
-  return { events, newObjects };
+  ctx.saveTimestampCursor("firebase:analytics");
+  logger.info("Firebase sync complete", { events, newObjects, updatedObjects });
+  return { events, newObjects, updatedObjects };
 }
 
 // src/sync/file-writer.ts
@@ -354,6 +349,8 @@ ${sanitizeContent(m.content)}`).join("\n");
           return join("feishu", "approvals", `${slugify(meta.title ?? "approval")}-${meta.id}.md`);
         if (sourceType === "document")
           return join("feishu", "docs", `${slugify(meta.title ?? "doc")}.md`);
+        if (sourceType === "link")
+          return join("feishu", "links", `${slugify(meta.title ?? meta.id)}.md`);
         return join("feishu", "other", `${meta.id}.md`);
       }
       case "posthog":
@@ -438,6 +435,30 @@ function elapsed(start) {
   const ms = Date.now() - start;
   return ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
 }
+function getSyncErrorHint(source, error) {
+  const is401 = /401|unauthorized|auth.*fail/i.test(error);
+  const is403 = /403|forbidden/i.test(error);
+  if (is401 || is403) {
+    switch (source) {
+      case "github":
+        return "Token invalid or expired. Create a new one at https://github.com/settings/tokens";
+      case "gitlab":
+        return "Token invalid. Check at https://gitlab.com/-/profile/personal_access_tokens";
+      case "feishu":
+        return "App ID/Secret invalid. Check at https://open.feishu.cn/app";
+      case "linear":
+        return "API key invalid. Get one at https://linear.app/settings/api";
+      case "posthog":
+        return "API key invalid. Get one at https://app.posthog.com/project/settings";
+      case "firebase":
+        return "API key invalid. Check at https://console.cloud.google.com \u2192 APIs & Services \u2192 Credentials";
+    }
+  }
+  if (/ENOTFOUND|ECONNREFUSED|network/i.test(error)) {
+    return "Network error. Check your internet connection and try again.";
+  }
+  return null;
+}
 async function runSync(sources) {
   const db = new DbManager(dbPath());
   db.ensureTables();
@@ -470,63 +491,82 @@ async function runSync(sources) {
     try {
       switch (source) {
         case "feishu": {
-          const result = await syncFeishu(db.getSqlite(), cred.data, logger, fileWriter);
+          const feishuCtx = new SyncContext(db.getSqlite(), logger, fileWriter);
+          const result = await syncFeishu(feishuCtx, cred.data, logger);
           resultLine(true, `${result.newMessages} new messages from ${result.chats} chats`);
           totalNew += result.newMessages;
           syncResults.push({ source: "feishu", newObjects: result.newMessages, label: "messages" });
           try {
-            const mr = await syncFeishuMeetings(db.getSqlite(), cred.data, logger, fileWriter);
+            const mr = await syncFeishuMeetings(feishuCtx, cred.data, logger);
             if (mr.newObjects > 0) resultLine(true, `${mr.newObjects} calendar events`);
             syncResults.push({ source: "feishu/meetings", newObjects: mr.newObjects, label: "events" });
           } catch {
           }
           try {
-            const dr = await syncFeishuDocs(db.getSqlite(), cred.data, logger, fileWriter);
+            const dr = await syncFeishuDocs(feishuCtx, cred.data, logger);
             if (dr.newObjects > 0) resultLine(true, `${dr.newObjects} documents`);
             syncResults.push({ source: "feishu/docs", newObjects: dr.newObjects, label: "docs" });
           } catch {
           }
           try {
-            const ar = await syncFeishuApprovals(db.getSqlite(), cred.data, logger, fileWriter);
+            const ar = await syncFeishuApprovals(feishuCtx, cred.data, logger);
             if (ar.newObjects > 0) resultLine(true, `${ar.newObjects} approvals`);
             syncResults.push({ source: "feishu/approvals", newObjects: ar.newObjects, label: "approvals" });
           } catch {
           }
+          try {
+            const lr = await syncFeishuLinks(feishuCtx, cred.data, logger);
+            if (lr.fetched > 0) resultLine(true, `${lr.fetched} link contents fetched (${lr.extracted} URLs found)`);
+            else if (lr.extracted > 0) resultLine(false, `${lr.extracted} URLs found, ${lr.failed} failed to fetch`);
+            syncResults.push({ source: "feishu/links", newObjects: lr.fetched, label: "links" });
+          } catch {
+          }
           break;
         }
         case "github": {
-          const r = await syncGitHub(db.getSqlite(), cred.data, logger, fileWriter);
-          resultLine(true, `${r.repos} repos, ${r.prs} PRs, ${r.issues} issues ${c.dim}(${r.newObjects} new)${c.reset}`);
+          const ghCtx = new SyncContext(db.getSqlite(), logger, fileWriter);
+          const r = await syncGitHub(ghCtx, cred.data, logger);
+          const changeInfo = r.updatedObjects > 0 ? `, ${r.updatedObjects} updated` : "";
+          const cloneInfo = r.clonedRepos > 0 ? ` | ${r.clonedRepos} repos cloned` : "";
+          resultLine(true, `${r.repos} repos, ${r.prs} PRs, ${r.issues} issues ${c.dim}(${r.newObjects} new${changeInfo})${cloneInfo}${c.reset}`);
           totalNew += r.newObjects;
-          syncResults.push({ source: "github", newObjects: r.newObjects });
+          syncResults.push({ source: "github", newObjects: r.newObjects + r.updatedObjects });
           break;
         }
         case "gitlab": {
-          const r = await syncGitLab(db.getSqlite(), cred.data, logger, fileWriter);
-          resultLine(true, `${r.projects} projects, ${r.mrs} MRs, ${r.issues} issues ${c.dim}(${r.newObjects} new)${c.reset}`);
+          const glCtx = new SyncContext(db.getSqlite(), logger, fileWriter);
+          const r = await syncGitLab(glCtx, cred.data, logger);
+          const glChangeInfo = r.updatedObjects > 0 ? `, ${r.updatedObjects} updated` : "";
+          resultLine(true, `${r.projects} projects, ${r.mrs} MRs, ${r.issues} issues ${c.dim}(${r.newObjects} new${glChangeInfo})${c.reset}`);
           totalNew += r.newObjects;
-          syncResults.push({ source: "gitlab", newObjects: r.newObjects });
+          syncResults.push({ source: "gitlab", newObjects: r.newObjects + r.updatedObjects });
           break;
         }
         case "linear": {
-          const r = await syncLinear(db.getSqlite(), cred.data, logger, fileWriter);
-          resultLine(true, `${r.issues} issues ${c.dim}(${r.newObjects} new)${c.reset}`);
+          const lnCtx = new SyncContext(db.getSqlite(), logger, fileWriter);
+          const r = await syncLinear(lnCtx, cred.data, logger);
+          const lnChangeInfo = r.updatedObjects > 0 ? `, ${r.updatedObjects} updated` : "";
+          resultLine(true, `${r.issues} issues ${c.dim}(${r.newObjects} new${lnChangeInfo})${c.reset}`);
           totalNew += r.newObjects;
-          syncResults.push({ source: "linear", newObjects: r.newObjects, label: "issues" });
+          syncResults.push({ source: "linear", newObjects: r.newObjects + r.updatedObjects, label: "issues" });
           break;
         }
         case "posthog": {
-          const r = await syncPostHog(db.getSqlite(), cred.data, logger, fileWriter);
-          resultLine(true, `${r.insights} insights, ${r.events} events ${c.dim}(${r.newObjects} new)${c.reset}`);
+          const phCtx = new SyncContext(db.getSqlite(), logger, fileWriter);
+          const r = await syncPostHog(phCtx, cred.data, logger);
+          const phChangeInfo = r.updatedObjects > 0 ? `, ${r.updatedObjects} updated` : "";
+          resultLine(true, `${r.insights} insights, ${r.events} events ${c.dim}(${r.newObjects} new${phChangeInfo})${c.reset}`);
           totalNew += r.newObjects;
-          syncResults.push({ source: "posthog", newObjects: r.newObjects });
+          syncResults.push({ source: "posthog", newObjects: r.newObjects + r.updatedObjects });
           break;
         }
         case "firebase": {
-          const r = await syncFirebase(db.getSqlite(), cred.data, logger, fileWriter);
-          resultLine(true, `${r.events} events ${c.dim}(${r.newObjects} new)${c.reset}`);
+          const fbCtx = new SyncContext(db.getSqlite(), logger, fileWriter);
+          const r = await syncFirebase(fbCtx, cred.data, logger);
+          const fbChangeInfo = r.updatedObjects > 0 ? `, ${r.updatedObjects} updated` : "";
+          resultLine(true, `${r.events} events ${c.dim}(${r.newObjects} new${fbChangeInfo})${c.reset}`);
           totalNew += r.newObjects;
-          syncResults.push({ source: "firebase", newObjects: r.newObjects, label: "events" });
+          syncResults.push({ source: "firebase", newObjects: r.newObjects + r.updatedObjects, label: "events" });
           break;
         }
         default:
@@ -535,7 +575,12 @@ async function runSync(sources) {
       console.log(`    ${c.dim}${elapsed(sourceStart)}${c.reset}`);
     } catch (err) {
       logError("sync", `Failed to sync ${source}`, { error: String(err) });
-      console.log(`    ${icon.fail} ${c.red}sync failed${c.reset} ${c.dim}${String(err).slice(0, 60)}${c.reset}`);
+      const errStr = String(err);
+      console.log(`    ${icon.fail} ${c.red}sync failed${c.reset} ${c.dim}${errStr.slice(0, 60)}${c.reset}`);
+      const hint = getSyncErrorHint(source, errStr);
+      if (hint) {
+        console.log(`    ${c.yellow}Hint: ${hint}${c.reset}`);
+      }
     }
     if (sources.length > 1) {
       console.log(`  ${progressBar(i + 1, sources.length)}`);
@@ -547,6 +592,38 @@ async function runSync(sources) {
   if (processed > 0) {
     resultLine(true, `${linksCreated} links from ${processed} objects`);
   }
+  try {
+    const sqlite = db.getSqlite();
+    const { readObjectContent } = await import("./content-reader-VPGTR2SF.js");
+    const noFilePath = sqlite.prepare(`
+      SELECT o.id, o.source, o.source_type, o.uri, o.title
+      FROM objects o
+      WHERE o.file_path IS NULL
+      LIMIT 500
+    `).all();
+    if (noFilePath.length > 0) {
+      console.log(`  ${icon.sync} ${c.dim}backfilling ${noFilePath.length} objects without files...${c.reset}`);
+      let backfilled = 0;
+      for (const obj of noFilePath) {
+        try {
+          const content = readObjectContent(sqlite, obj.id, null);
+          if (!content) continue;
+          const filePath = fileWriter.writeObject(obj.source, obj.source_type, {
+            id: obj.id,
+            title: obj.title,
+            uri: obj.uri
+          }, content);
+          sqlite.prepare("UPDATE objects SET file_path = ? WHERE id = ?").run(filePath, obj.id);
+          backfilled++;
+        } catch {
+        }
+      }
+      if (backfilled > 0) {
+        resultLine(true, `${backfilled} files backfilled`);
+      }
+    }
+  } catch {
+  }
   db.close();
   if (gitManager) {
     try {