threadnote 0.7.0 → 0.7.2

package/dist/mcp_server.cjs

@@ -34108,10 +34108,8 @@ async function runShareSyncQuiet(config2, state, options) {
   const git = await requiredExecutable("git");
   const worktree = team.config.worktree;
   const pendingChanges = state.pendingReindexes.get(team.name);
-  if (pendingChanges) {
-    await applyChangesToOpenViking(config2, team.config, pendingChanges, { quiet: true });
-    state.pendingReindexes.delete(team.name);
-    await writePendingReindexes(config2, state);
+  if (pendingChanges && pendingChanges.length > 0) {
+    await applyAndPersistChanges(config2, team.config, state, pendingChanges, { quiet: true });
   }
   if (await hasUncommittedChanges(worktree)) {
     return `Shared team "${team.name}" has uncommitted changes; skipped automatic sync. Run \`threadnote share sync --team ${team.name}\` to publish or resolve them.`;
@@ -34139,11 +34137,9 @@ async function runShareSyncQuiet(config2, state, options) {
   if (beforeRev && afterRev && beforeRev !== afterRev) {
     const changes = await listChangedFiles(worktree, beforeRev, afterRev);
     if (changes.length > 0) {
-      state.pendingReindexes.set(team.name, changes);
-      await writePendingReindexes(config2, state);
-      await applyChangesToOpenViking(config2, team.config, changes, { quiet: true });
-      state.pendingReindexes.delete(team.name);
-      await writePendingReindexes(config2, state);
+      const stillPending = state.pendingReindexes.get(team.name) ?? [];
+      const combined = mergeChanges(stillPending, changes);
+      await applyAndPersistChanges(config2, team.config, state, combined, { quiet: true });
     }
   }
   return void 0;
@@ -34339,8 +34335,9 @@ async function writeMemoryFile(config2, ov, uri, content, initialMode, dryRun, o
     await (0, import_promises3.rm)(stagingDir, { force: true, recursive: true });
   }
 }
+var BUSY_RETRY_BACKOFF_MS = [2e3, 5e3, 1e4, 2e4, 3e4];
 async function writeOvFileWithRetry(config2, ov, uri, fromFile, initialMode, options = {}) {
-  const maxAttempts = 4;
+  const maxAttempts = BUSY_RETRY_BACKOFF_MS.length + 1;
   const existedBeforeWrite = await vikingResourceExists(ov, config2, uri);
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
     const existsNow = attempt === 0 ? existedBeforeWrite : await vikingResourceExists(ov, config2, uri);
@@ -34382,7 +34379,12 @@ async function writeOvFileWithRetry(config2, ov, uri, fromFile, initialMode, opt
     if (!isTransientOvFailure(result.stderr, result.stdout) || attempt === maxAttempts - 1) {
       throw new Error(`${formatShellCommand(ov, args)} failed: ${result.stderr || result.stdout}`);
     }
-    await sleep(1e3 * (attempt + 1));
+    if (isResourceBusyFailure(result.stderr, result.stdout)) {
+      await waitForOvQueue(ov, config2, options);
+      await sleep(BUSY_RETRY_BACKOFF_MS[attempt] ?? 3e4);
+    } else {
+      await sleep(1e3 * (attempt + 1));
+    }
   }
 }
 async function waitForOvQueue(ov, config2, options = {}) {
@@ -34399,6 +34401,11 @@ function isTransientOvFailure(stderr, stdout) {
 ${stdout}`.toLowerCase();
   return output.includes("resource is busy") || output.includes("resource is being processed") || output.includes("network error") || output.includes("error sending request") || output.includes("http request failed") || output.includes("connection refused") || output.includes("connection reset") || output.includes("timed out");
 }
+function isResourceBusyFailure(stderr, stdout) {
+  const output = `${stderr}
+${stdout}`.toLowerCase();
+  return output.includes("resource is busy") || output.includes("resource is being processed");
+}
 async function ingestSingleFile(ov, config2, uri, filePath, initialMode, options = {}) {
   const content = await (0, import_promises3.readFile)(filePath, "utf8");
   await writeMemoryFile(config2, ov, uri, content, initialMode, false, options);
@@ -34452,7 +34459,7 @@ async function removeMemoryUri(config2, ov, uri, dryRun, options = {}) {
     }
     return;
   }
-  const maxAttempts = 4;
+  const maxAttempts = BUSY_RETRY_BACKOFF_MS.length + 1;
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
     const result = await runCommand(ov, args, { allowFailure: true });
     if (result.exitCode === 0) {
@@ -34464,7 +34471,12 @@ async function removeMemoryUri(config2, ov, uri, dryRun, options = {}) {
     if (!isTransientOvFailure(result.stderr, result.stdout) || attempt === maxAttempts - 1) {
       throw new Error(`${formatShellCommand(ov, args)} failed: ${result.stderr || result.stdout}`);
     }
-    await sleep(1e3 * (attempt + 1));
+    if (isResourceBusyFailure(result.stderr, result.stdout)) {
+      await waitForOvQueue(ov, config2, options);
+      await sleep(BUSY_RETRY_BACKOFF_MS[attempt] ?? 3e4);
+    } else {
+      await sleep(1e3 * (attempt + 1));
+    }
   }
 }
 async function vikingResourceExists(ov, config2, uri) {
@@ -34518,6 +34530,7 @@ async function listChangedFiles(worktree, beforeRev, afterRev) {
 }
 async function applyChangesToOpenViking(config2, team, changes, options = {}) {
   const ov = await openVikingCliForMode(false);
+  const failed = [];
   for (const change of changes) {
     if (!change.relativePath.endsWith(".md")) {
       continue;
@@ -34527,24 +34540,57 @@ async function applyChangesToOpenViking(config2, team, changes, options = {}) {
       continue;
     }
     const uri = workfileToVikingUri(config2, team, change.path);
-    if (change.status === "removed") {
-      await removeMemoryUri(config2, ov, uri, false, options);
-      continue;
-    }
-    if (!await isFile(change.path)) {
-      continue;
-    }
-    const ovHasResource = await vikingResourceExists(ov, config2, uri);
-    if (ovHasResource) {
-      const reason = change.status === "modified" ? "overwriting local with upstream (local edits to the shared subtree are not preserved across sync)" : "aligning OV to upstream (resource pre-existed in OV, likely from an earlier local publish or sync)";
+    try {
+      if (change.status === "removed") {
+        await removeMemoryUri(config2, ov, uri, false, options);
+        continue;
+      }
+      if (!await isFile(change.path)) {
+        continue;
+      }
+      const ovHasResource = await vikingResourceExists(ov, config2, uri);
+      if (ovHasResource) {
+        const reason = change.status === "modified" ? "overwriting local with upstream (local edits to the shared subtree are not preserved across sync)" : "aligning OV to upstream (resource pre-existed in OV, likely from an earlier local publish or sync)";
+        if (options.quiet !== true) {
+          console.warn(`share sync: ${uri}: ${reason}.`);
+        }
+      }
+      await ensureSharedDirectoryChain(config2, ov, uri, false, options);
+      const writeMode = ovHasResource ? "replace" : "create";
+      await ingestSingleFile(ov, config2, uri, change.path, writeMode, options);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
       if (options.quiet !== true) {
-        console.warn(`share sync: ${uri}: ${reason}.`);
+        console.warn(`share sync: ${uri}: ingest failed \u2014 will retry on the next sync. ${message}`);
       }
+      failed.push(change);
     }
-    await ensureSharedDirectoryChain(config2, ov, uri, false, options);
-    const writeMode = ovHasResource ? "replace" : "create";
-    await ingestSingleFile(ov, config2, uri, change.path, writeMode, options);
   }
+  return { failed };
+}
+function mergeChanges(...lists) {
+  const map3 = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    for (const change of list) {
+      map3.set(change.relativePath, change);
+    }
+  }
+  return [...map3.values()];
+}
+async function applyAndPersistChanges(config2, team, state, changes, options = {}) {
+  if (changes.length === 0) {
+    return { failed: [] };
+  }
+  state.pendingReindexes.set(team.name, changes);
+  await writePendingReindexes(config2, state);
+  const result = await applyChangesToOpenViking(config2, team, changes, options);
+  if (result.failed.length > 0) {
+    state.pendingReindexes.set(team.name, result.failed);
+  } else {
+    state.pendingReindexes.delete(team.name);
+  }
+  await writePendingReindexes(config2, state);
+  return result;
 }
 
 // src/mcp_server.ts

package/dist/threadnote.cjs

@@ -7583,12 +7583,24 @@ Resolve the conflicts in-place, run \`git -C ${worktree} rebase --continue\` (or
     );
   }
   const afterRev = await gitOutput(worktree, ["rev-parse", "HEAD"], dryRun);
-  if (!dryRun && beforeRev && afterRev && beforeRev !== afterRev) {
-    const changes = await listChangedFiles(worktree, beforeRev, afterRev);
-    await applyChangesToOpenViking(config, team.config, changes);
-    console.log(`Reindexed ${changes.length} file change(s) into OpenViking.`);
-  } else if (!dryRun) {
-    console.log("No upstream changes to reindex.");
+  if (!dryRun) {
+    const state = autoShareState(config);
+    await loadPendingReindexes(config, state);
+    const previouslyPending = state.pendingReindexes.get(team.name) ?? [];
+    const newChanges = beforeRev && afterRev && beforeRev !== afterRev ? await listChangedFiles(worktree, beforeRev, afterRev) : [];
+    const combined = mergeChanges(previouslyPending, newChanges);
+    if (combined.length === 0) {
+      console.log("No upstream changes to reindex.");
+    } else {
+      const result = await applyAndPersistChanges(config, team.config, state, combined);
+      const succeeded = combined.length - result.failed.length;
+      console.log(`Reindexed ${succeeded} file change(s) into OpenViking.`);
+      if (result.failed.length > 0) {
+        console.warn(
+          `share sync: ${result.failed.length} file(s) could not be ingested on this run; they are persisted and will be retried on the next sync or agent recall/read.`
+        );
+      }
+    }
   }
   if (options.push !== false) {
     await maybeRun(dryRun, git, ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
@@ -7599,10 +7611,8 @@ async function runShareSyncQuiet(config, state, options) {
   const git = await requiredExecutable("git");
   const worktree = team.config.worktree;
   const pendingChanges = state.pendingReindexes.get(team.name);
-  if (pendingChanges) {
-    await applyChangesToOpenViking(config, team.config, pendingChanges, { quiet: true });
-    state.pendingReindexes.delete(team.name);
-    await writePendingReindexes(config, state);
+  if (pendingChanges && pendingChanges.length > 0) {
+    await applyAndPersistChanges(config, team.config, state, pendingChanges, { quiet: true });
   }
   if (await hasUncommittedChanges(worktree)) {
     return `Shared team "${team.name}" has uncommitted changes; skipped automatic sync. Run \`threadnote share sync --team ${team.name}\` to publish or resolve them.`;
@@ -7630,11 +7640,9 @@ async function runShareSyncQuiet(config, state, options) {
   if (beforeRev && afterRev && beforeRev !== afterRev) {
     const changes = await listChangedFiles(worktree, beforeRev, afterRev);
     if (changes.length > 0) {
-      state.pendingReindexes.set(team.name, changes);
-      await writePendingReindexes(config, state);
-      await applyChangesToOpenViking(config, team.config, changes, { quiet: true });
-      state.pendingReindexes.delete(team.name);
-      await writePendingReindexes(config, state);
+      const stillPending = state.pendingReindexes.get(team.name) ?? [];
+      const combined = mergeChanges(stillPending, changes);
+      await applyAndPersistChanges(config, team.config, state, combined, { quiet: true });
     }
   }
   return void 0;
@@ -8074,8 +8082,9 @@ async function writeMemoryFile(config, ov, uri, content, initialMode, dryRun, op
     await (0, import_promises4.rm)(stagingDir, { force: true, recursive: true });
   }
 }
+var BUSY_RETRY_BACKOFF_MS = [2e3, 5e3, 1e4, 2e4, 3e4];
 async function writeOvFileWithRetry(config, ov, uri, fromFile, initialMode, options = {}) {
-  const maxAttempts = 4;
+  const maxAttempts = BUSY_RETRY_BACKOFF_MS.length + 1;
   const existedBeforeWrite = await vikingResourceExists(ov, config, uri);
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
     const existsNow = attempt === 0 ? existedBeforeWrite : await vikingResourceExists(ov, config, uri);
@@ -8117,7 +8126,12 @@ async function writeOvFileWithRetry(config, ov, uri, fromFile, initialMode, opti
     if (!isTransientOvFailure(result.stderr, result.stdout) || attempt === maxAttempts - 1) {
       throw new Error(`${formatShellCommand(ov, args)} failed: ${result.stderr || result.stdout}`);
     }
-    await sleep(1e3 * (attempt + 1));
+    if (isResourceBusyFailure(result.stderr, result.stdout)) {
+      await waitForOvQueue(ov, config, options);
+      await sleep(BUSY_RETRY_BACKOFF_MS[attempt] ?? 3e4);
+    } else {
+      await sleep(1e3 * (attempt + 1));
+    }
   }
 }
 async function waitForOvQueue(ov, config, options = {}) {
@@ -8134,6 +8148,11 @@ function isTransientOvFailure(stderr, stdout) {
 ${stdout}`.toLowerCase();
   return output2.includes("resource is busy") || output2.includes("resource is being processed") || output2.includes("network error") || output2.includes("error sending request") || output2.includes("http request failed") || output2.includes("connection refused") || output2.includes("connection reset") || output2.includes("timed out");
 }
+function isResourceBusyFailure(stderr, stdout) {
+  const output2 = `${stderr}
+${stdout}`.toLowerCase();
+  return output2.includes("resource is busy") || output2.includes("resource is being processed");
+}
 async function ingestSingleFile(ov, config, uri, filePath, initialMode, options = {}) {
   const content = await (0, import_promises4.readFile)(filePath, "utf8");
   await writeMemoryFile(config, ov, uri, content, initialMode, false, options);
@@ -8187,7 +8206,7 @@ async function removeMemoryUri(config, ov, uri, dryRun, options = {}) {
     }
     return;
   }
-  const maxAttempts = 4;
+  const maxAttempts = BUSY_RETRY_BACKOFF_MS.length + 1;
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
     const result = await runCommand(ov, args, { allowFailure: true });
     if (result.exitCode === 0) {
@@ -8199,7 +8218,12 @@ async function removeMemoryUri(config, ov, uri, dryRun, options = {}) {
     if (!isTransientOvFailure(result.stderr, result.stdout) || attempt === maxAttempts - 1) {
       throw new Error(`${formatShellCommand(ov, args)} failed: ${result.stderr || result.stdout}`);
     }
-    await sleep(1e3 * (attempt + 1));
+    if (isResourceBusyFailure(result.stderr, result.stdout)) {
+      await waitForOvQueue(ov, config, options);
+      await sleep(BUSY_RETRY_BACKOFF_MS[attempt] ?? 3e4);
+    } else {
+      await sleep(1e3 * (attempt + 1));
+    }
   }
 }
 async function vikingResourceExists(ov, config, uri) {
@@ -8253,6 +8277,7 @@ async function listChangedFiles(worktree, beforeRev, afterRev) {
 }
 async function applyChangesToOpenViking(config, team, changes, options = {}) {
   const ov = await openVikingCliForMode(false);
+  const failed = [];
   for (const change of changes) {
     if (!change.relativePath.endsWith(".md")) {
       continue;
@@ -8262,24 +8287,57 @@ async function applyChangesToOpenViking(config, team, changes, options = {}) {
       continue;
     }
     const uri = workfileToVikingUri(config, team, change.path);
-    if (change.status === "removed") {
-      await removeMemoryUri(config, ov, uri, false, options);
-      continue;
-    }
-    if (!await isFile(change.path)) {
-      continue;
-    }
-    const ovHasResource = await vikingResourceExists(ov, config, uri);
-    if (ovHasResource) {
-      const reason = change.status === "modified" ? "overwriting local with upstream (local edits to the shared subtree are not preserved across sync)" : "aligning OV to upstream (resource pre-existed in OV, likely from an earlier local publish or sync)";
+    try {
+      if (change.status === "removed") {
+        await removeMemoryUri(config, ov, uri, false, options);
+        continue;
+      }
+      if (!await isFile(change.path)) {
+        continue;
+      }
+      const ovHasResource = await vikingResourceExists(ov, config, uri);
+      if (ovHasResource) {
+        const reason = change.status === "modified" ? "overwriting local with upstream (local edits to the shared subtree are not preserved across sync)" : "aligning OV to upstream (resource pre-existed in OV, likely from an earlier local publish or sync)";
+        if (options.quiet !== true) {
+          console.warn(`share sync: ${uri}: ${reason}.`);
+        }
+      }
+      await ensureSharedDirectoryChain(config, ov, uri, false, options);
+      const writeMode = ovHasResource ? "replace" : "create";
+      await ingestSingleFile(ov, config, uri, change.path, writeMode, options);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
       if (options.quiet !== true) {
-        console.warn(`share sync: ${uri}: ${reason}.`);
+        console.warn(`share sync: ${uri}: ingest failed \u2014 will retry on the next sync. ${message}`);
       }
+      failed.push(change);
     }
-    await ensureSharedDirectoryChain(config, ov, uri, false, options);
-    const writeMode = ovHasResource ? "replace" : "create";
-    await ingestSingleFile(ov, config, uri, change.path, writeMode, options);
   }
+  return { failed };
+}
+function mergeChanges(...lists) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    for (const change of list) {
+      map2.set(change.relativePath, change);
+    }
+  }
+  return [...map2.values()];
+}
+async function applyAndPersistChanges(config, team, state, changes, options = {}) {
+  if (changes.length === 0) {
+    return { failed: [] };
+  }
+  state.pendingReindexes.set(team.name, changes);
+  await writePendingReindexes(config, state);
+  const result = await applyChangesToOpenViking(config, team, changes, options);
+  if (result.failed.length > 0) {
+    state.pendingReindexes.set(team.name, result.failed);
+  } else {
+    state.pendingReindexes.delete(team.name);
+  }
+  await writePendingReindexes(config, state);
+  return result;
 }
 
 // src/memory.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadnote",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "type": "commonjs",
   "main": "dist/threadnote.cjs",
   "description": "Shared local context and handoffs for development agents",