threadnote 0.7.7 → 0.7.9

package/dist/mcp_server.cjs

@@ -28477,25 +28477,25 @@ var Protocol = class {
     });
   }
   _resetTimeout(messageId) {
-    const info = this._timeoutInfo.get(messageId);
-    if (!info)
+    const info2 = this._timeoutInfo.get(messageId);
+    if (!info2)
       return false;
-    const totalElapsed = Date.now() - info.startTime;
-    if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) {
+    const totalElapsed = Date.now() - info2.startTime;
+    if (info2.maxTotalTimeout && totalElapsed >= info2.maxTotalTimeout) {
       this._timeoutInfo.delete(messageId);
       throw McpError.fromError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
-        maxTotalTimeout: info.maxTotalTimeout,
+        maxTotalTimeout: info2.maxTotalTimeout,
         totalElapsed
       });
     }
-    clearTimeout(info.timeoutId);
-    info.timeoutId = setTimeout(info.onTimeout, info.timeout);
+    clearTimeout(info2.timeoutId);
+    info2.timeoutId = setTimeout(info2.onTimeout, info2.timeout);
     return true;
   }
   _cleanupTimeout(messageId) {
-    const info = this._timeoutInfo.get(messageId);
-    if (info) {
-      clearTimeout(info.timeoutId);
+    const info2 = this._timeoutInfo.get(messageId);
+    if (info2) {
+      clearTimeout(info2.timeoutId);
       this._timeoutInfo.delete(messageId);
     }
   }
@@ -28540,8 +28540,8 @@ var Protocol = class {
     this._progressHandlers.clear();
     this._taskProgressTokens.clear();
     this._pendingDebouncedNotifications.clear();
-    for (const info of this._timeoutInfo.values()) {
-      clearTimeout(info.timeoutId);
+    for (const info2 of this._timeoutInfo.values()) {
+      clearTimeout(info2.timeoutId);
     }
     this._timeoutInfo.clear();
     for (const controller of this._requestHandlerAbortControllers.values()) {
@@ -30036,8 +30036,8 @@ function validateToolName(name) {
 function issueToolNameWarning(name, warnings) {
   if (warnings.length > 0) {
     console.warn(`Tool name validation warning for "${name}":`);
-    for (const warning of warnings) {
-      console.warn(`  - ${warning}`);
+    for (const warning2 of warnings) {
+      console.warn(`  - ${warning2}`);
     }
     console.warn("Tool registration will proceed, but this may cause compatibility issues.");
     console.warn("Consider updating the tool name to conform to the MCP tool naming standard.");
@@ -33591,6 +33591,39 @@ var import_node_crypto = require("node:crypto");
 var import_promises = require("node:fs/promises");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
+
+// src/cli_ui.ts
+var import_node_process2 = require("node:process");
+var ANSI = {
+  blue: "\x1B[34m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  reset: "\x1B[0m",
+  yellow: "\x1B[33m"
+};
+function color(name, text) {
+  if (!shouldUseColor()) {
+    return text;
+  }
+  return `${ANSI[name]}${text}${ANSI.reset}`;
+}
+function command(text) {
+  return color("cyan", text);
+}
+function info(text) {
+  return color("cyan", text);
+}
+function warning(text) {
+  return color("yellow", text);
+}
+function shouldUseColor() {
+  return import_node_process2.stdout.isTTY === true && process.env.NO_COLOR === void 0 && process.env.CI === void 0 && process.env.TERM !== "dumb";
+}
+
+// src/utils.ts
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -33609,11 +33642,11 @@ function redactText(content) {
   ).replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [REDACTED]").replace(/sk-[A-Za-z0-9_-]{16,}/g, "sk-[REDACTED]").replace(/gh[pousr]_[A-Za-z0-9_]{16,}/g, "gh_[REDACTED]");
 }
 async function requiredOpenVikingCli() {
-  const command = await findExecutable(["ov", "openviking"]);
-  if (!command) {
+  const command2 = await findExecutable(["ov", "openviking"]);
+  if (!command2) {
     throw new Error("Neither ov nor openviking was found in PATH. Run threadnote install first.");
   }
-  return command;
+  return command2;
 }
 async function openVikingCliForMode(dryRun) {
   if (dryRun) {
@@ -33621,16 +33654,16 @@ async function openVikingCliForMode(dryRun) {
   }
   return requiredOpenVikingCli();
 }
-async function requiredExecutable(command) {
-  const executable = await findExecutable([command]);
+async function requiredExecutable(command2) {
+  const executable = await findExecutable([command2]);
   if (!executable) {
-    throw new Error(`${command} was not found in PATH.`);
+    throw new Error(`${command2} was not found in PATH.`);
   }
   return executable;
 }
 async function findExecutable(commands) {
-  for (const command of commands) {
-    const result = await runCommand("which", [command], { allowFailure: true });
+  for (const command2 of commands) {
+    const result = await runCommand("which", [command2], { allowFailure: true });
     if (result.exitCode === 0 && result.stdout.trim()) {
       return result.stdout.trim();
     }
@@ -33639,7 +33672,8 @@ async function findExecutable(commands) {
 }
 async function maybeRun(dryRun, executable, args, options = {}) {
   const cwdSuffix = options.cwd ? ` (cwd: ${options.cwd})` : "";
-  console.log(`${dryRun ? "Would run" : "Running"}: ${formatShellCommand(executable, args)}${cwdSuffix}`);
+  const label = dryRun ? warning("Would run") : info("Running");
+  console.log(`${label}: ${command(formatShellCommand(executable, args))}${cwdSuffix}`);
   if (dryRun) {
     return void 0;
   }
@@ -33657,33 +33691,111 @@ async function runCommand(executable, args, options = {}) {
     const child = (0, import_node_child_process.spawn)(executable, args, { cwd: options.cwd });
     const stdoutChunks = [];
     const stderrChunks = [];
+    const maxOutputBytes = options.maxOutputBytes ?? defaultCommandMaxOutputBytes();
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let finished = false;
+    let failureResult;
+    let killTimer;
+    let sentTerminationSignal = false;
+    const timeoutMs = options.timeoutMs ?? defaultCommandTimeoutMs();
+    const finish = (result) => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      if (killTimer) {
+        clearTimeout(killTimer);
+      }
+      if (result.exitCode !== 0 && options.allowFailure !== true) {
+        rejectPromise(new Error(`${formatShellCommand(executable, args)} failed: ${result.stderr || result.stdout}`));
+        return;
+      }
+      resolvePromise(result);
+    };
+    const failAndKill = (message) => {
+      if (failureResult) {
+        return;
+      }
+      failureResult = { exitCode: 124, stderr: message, stdout: stdoutChunks.join("") };
+      if (!sentTerminationSignal) {
+        sentTerminationSignal = true;
+        child.kill("SIGTERM");
+      }
+      setTimeout(() => {
+        if (!finished) {
+          child.kill("SIGKILL");
+        }
+      }, 1e3).unref?.();
+    };
+    if (timeoutMs > 0) {
+      killTimer = setTimeout(() => {
+        failAndKill(`${formatShellCommand(executable, args)} timed out after ${timeoutMs}ms`);
+      }, timeoutMs);
+      killTimer.unref?.();
+    }
     child.stdout.on("data", (chunk) => {
-      stdoutChunks.push(String(chunk));
+      if (failureResult) {
+        return;
+      }
+      const text = String(chunk);
+      stdoutBytes += Buffer.byteLength(text);
+      if (stdoutBytes + stderrBytes > maxOutputBytes) {
+        failAndKill(`${formatShellCommand(executable, args)} exceeded output limit of ${maxOutputBytes} bytes`);
+        return;
+      }
+      stdoutChunks.push(text);
     });
     child.stderr.on("data", (chunk) => {
-      stderrChunks.push(String(chunk));
+      if (failureResult) {
+        return;
+      }
+      const text = String(chunk);
+      stderrBytes += Buffer.byteLength(text);
+      if (stdoutBytes + stderrBytes > maxOutputBytes) {
+        failAndKill(`${formatShellCommand(executable, args)} exceeded output limit of ${maxOutputBytes} bytes`);
+        return;
+      }
+      stderrChunks.push(text);
     });
     child.on("error", (err) => {
+      if (finished) {
+        return;
+      }
+      if (killTimer) {
+        clearTimeout(killTimer);
+      }
       if (options.allowFailure === true) {
-        resolvePromise({ exitCode: 127, stderr: errorMessage(err), stdout: "" });
+        finish({ exitCode: 127, stderr: errorMessage(err), stdout: "" });
       } else {
+        finished = true;
         rejectPromise(err);
       }
     });
     child.on("close", (code) => {
-      const result = {
+      const result = failureResult ?? {
         exitCode: code ?? 1,
         stderr: stderrChunks.join(""),
         stdout: stdoutChunks.join("")
       };
-      if (result.exitCode !== 0 && options.allowFailure !== true) {
-        rejectPromise(new Error(`${formatShellCommand(executable, args)} failed: ${result.stderr || result.stdout}`));
-        return;
-      }
-      resolvePromise(result);
+      finish(result);
     });
   });
 }
+function defaultCommandTimeoutMs() {
+  return positiveIntegerFromEnv("THREADNOTE_COMMAND_TIMEOUT_MS") ?? 10 * 60 * 1e3;
+}
+function defaultCommandMaxOutputBytes() {
+  return positiveIntegerFromEnv("THREADNOTE_COMMAND_MAX_OUTPUT_BYTES") ?? 5 * 1024 * 1024;
+}
+function positiveIntegerFromEnv(name) {
+  const value = process.env[name];
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
 async function gitValue(args, cwd = getInvocationCwd()) {
   const result = await runCommand("git", args, { allowFailure: true, cwd });
   if (result.exitCode !== 0) {
@@ -34445,9 +34557,9 @@ async function syncSharedReposBeforeAgentRead(config2) {
     const remainingBehind = new Set(state.behindTeams);
     for (const team of syncTeams) {
       try {
-        const warning = await runShareSyncQuiet(config2, state, { team });
-        if (warning) {
-          warnings.push(warning);
+        const warning2 = await runShareSyncQuiet(config2, state, { team });
+        if (warning2) {
+          warnings.push(warning2);
         } else {
           remainingBehind.delete(team);
           syncedTeams.push(team);
@@ -34529,8 +34641,8 @@ async function refreshShareUpdateState(config2, options) {
     state,
     async () => refreshShareUpdateStateLocked(config2, state, options)
   );
-  for (const warning of warnings) {
-    console.error(warning);
+  for (const warning2 of warnings) {
+    console.error(warning2);
   }
 }
 async function refreshShareUpdateStateLocked(config2, state, options) {
@@ -34637,6 +34749,58 @@ async function runShareSyncQuiet(config2, state, options) {
   }
   return void 0;
 }
+async function publishShareGitChange(worktree, relativePath, commitMessage, options = {}) {
+  const dryRun = options.dryRun === true;
+  const push = options.push !== false;
+  const verb = options.verb ?? "add";
+  const git = await requiredExecutable("git");
+  const messages = [];
+  const stageArgs = verb === "rm" ? ["-C", worktree, "rm", relativePath] : ["-C", worktree, "add", "--", relativePath];
+  const stageResult = await runGitCommand(dryRun, git, stageArgs, `git ${verb} failed`);
+  if (stageResult) {
+    messages.push(`git ${verb}: ${stageResult.stdout.trim() || "ok"}`);
+  }
+  if (dryRun) {
+    console.log(`Would run: ${formatShellCommand(git, ["-C", worktree, "commit", "-m", commitMessage])}`);
+  } else {
+    const commitResult = await runCommand(git, ["-C", worktree, "commit", "-m", commitMessage], { allowFailure: true });
+    if (commitResult.exitCode !== 0) {
+      const detail = commitResult.stdout.trim() || commitResult.stderr.trim();
+      if (/nothing to commit|no changes added/i.test(detail)) {
+        messages.push("git commit: nothing to commit (file already in tree)");
+      } else {
+        throw new Error(`git commit failed: ${detail || "unknown error"}`);
+      }
+    } else {
+      messages.push(`git commit: ${commitResult.stdout.trim().split("\n").slice(0, 2).join(" ")}`);
+    }
+  }
+  if (!push) {
+    messages.push("git push skipped (push=false)");
+    return messages;
+  }
+  const pushResult = await runGitCommand(
+    dryRun,
+    git,
+    ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME],
+    "git push failed"
+  );
+  if (pushResult) {
+    messages.push(`git push: ${pushResult.stdout.trim() || pushResult.stderr.trim() || "ok"}`);
+  }
+  return messages;
+}
+async function runGitCommand(dryRun, git, args, failureLabel) {
+  if (dryRun) {
+    console.log(`Would run: ${formatShellCommand(git, args)}`);
+    return void 0;
+  }
+  const result = await runCommand(git, args, { allowFailure: true });
+  if (result.exitCode !== 0) {
+    throw new Error(`${failureLabel}: ${result.stderr.trim() || result.stdout.trim() || "unknown error"}`);
+  }
+  return result;
+}
 function normalizeTeamName(input) {
   const candidate = (input ?? "default").trim();
   if (!candidate) {
@@ -34917,61 +35081,20 @@ async function waitForOvQueue(ov, config2, options = {}) {
     console.error(result.stderr.trim());
   }
 }
-function isTransientOvFailure(stderr, stdout) {
+function isTransientOvFailure(stderr, stdout2) {
   const output = `${stderr}
-${stdout}`.toLowerCase();
+${stdout2}`.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) {
+function isResourceBusyFailure(stderr, stdout2) {
   const output = `${stderr}
-${stdout}`.toLowerCase();
+${stdout2}`.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);
 }
-async function removeWithRollback(config2, ov, sourceUri, rollbackUri, worktree, dryRun, label) {
-  try {
-    await removeMemoryUri(config2, ov, sourceUri, dryRun);
-  } catch (sourceErr) {
-    if (dryRun) {
-      throw sourceErr;
-    }
-    console.error(
-      `Source removal failed during ${label}; rolling back ${rollbackUri} so the system is back to the pre-${label} state.`
-    );
-    try {
-      await removeMemoryUri(config2, ov, rollbackUri, false);
-    } catch (rollbackErr) {
-      console.error(
-        `Rollback of ${rollbackUri} also failed. Manual cleanup needed via: threadnote forget ${rollbackUri}
-Rollback error: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}`
-      );
-    }
-    await bestEffortRemoveWorktreeFile(rollbackUri, worktree, label);
-    throw sourceErr;
-  }
-}
-async function bestEffortRemoveWorktreeFile(rollbackUri, worktree, label) {
-  if (label !== "publish") {
-    return;
-  }
-  const prefix = "viking://";
-  if (!rollbackUri.startsWith(prefix)) {
-    return;
-  }
-  const parts = rollbackUri.slice(prefix.length).split("/");
-  const sharedIndex = parts.indexOf("shared");
-  if (sharedIndex === -1 || sharedIndex + 2 >= parts.length) {
-    return;
-  }
-  const relative2 = parts.slice(sharedIndex + 2).join("/");
-  if (!relative2) {
-    return;
-  }
-  await (0, import_promises3.rm)((0, import_node_path3.join)(worktree, relative2), { force: true });
-}
 async function removeMemoryUri(config2, ov, uri, dryRun, options = {}) {
   const args = withIdentity(config2, ["rm", uri]);
   if (dryRun) {
@@ -35133,7 +35256,7 @@ async function main() {
         "During feature work, update durable feature knowledge when valuable implementation details, decisions, interfaces, or gotchas change.",
         "When updating the same active issue, pass project/topic or replaceUri to remember_context so duplicate durable memories or handoffs do not accumulate.",
         "Use compact_context with dryRun=true for scoped memory hygiene when recall surfaces overlapping active memories.",
-        "To share a durable memory with teammates, call `share_publish` with its viking:// URI. share_publish is destructive: it scrubs for secrets, moves the memory into the shared subtree, removes the personal copy, and pushes a git commit. Do not publish handoffs, preferences, or anything carrying machine-local paths or in-flight task context.",
+        "To share a durable memory with teammates, call `share_publish` with its viking:// URI. share_publish scrubs for secrets, writes and pushes the shared copy first, then removes the personal copy after the push succeeds. Do not publish handoffs, preferences, or anything carrying machine-local paths or in-flight task context.",
         "Do not store secrets, customer data, raw production logs, or credentials."
       ].join("\n")
     }
@@ -35317,7 +35440,7 @@ function registerTools(server, config2) {
     "share_publish",
     {
       annotations: { readOnlyHint: false, destructiveHint: true },
-      description: "Publish a personal memory into a team's shared memories git repo. Reads the memory, strips local-only provenance frontmatter (supersedes:, archived_from:), refuses publish if it matches secret patterns, copies it into the shared subtree, removes the personal original, and commits/pushes. Default team is used unless team is provided. Pass preview=true to return the would-be-published bytes without writing or committing.",
+      description: "Publish a personal memory into a team's shared memories git repo. Reads the memory, strips local-only provenance frontmatter (supersedes:, archived_from:), refuses publish if it matches secret patterns, writes and pushes the shared copy first, then removes the personal original. Default team is used unless team is provided. Pass preview=true to return the would-be-published bytes without writing or committing.",
       inputSchema: {
         message: external_exports.string().optional().describe('Commit message override; defaults to "share: publish <path>"'),
         preview: external_exports.boolean().optional().describe(
@@ -35428,8 +35551,8 @@ ${exactMatches}`);
   if (syncedTeams.length > 0) {
     sections.push(`Auto-synced shared memories: ${syncedTeams.join(", ")}`);
   }
-  for (const warning of syncWarnings) {
-    sections.push(`Auto-sync warning: ${warning}`);
+  for (const warning2 of syncWarnings) {
+    sections.push(`Auto-sync warning: ${warning2}`);
   }
   if (sections.length <= 1) {
     return semanticResult;
@@ -35527,7 +35650,7 @@ function registerReadTool(server, config2, name, description) {
       }
       const syncMessages = [
         syncedTeams.length > 0 ? `Auto-synced shared memories: ${syncedTeams.join(", ")}` : void 0,
-        ...syncWarnings.map((warning) => `Auto-sync warning: ${warning}`)
+        ...syncWarnings.map((warning2) => `Auto-sync warning: ${warning2}`)
       ].filter((part) => part !== void 0);
       return {
         ...result,
@@ -35715,27 +35838,8 @@ function registerCompactTool(server, config2) {
         const ov = await requiredOpenVikingCli2();
         const appliedMessages = [];
         for (const action of plan.keepUpdates) {
-          const result = await runOpenVikingWriteWithRetry(
-            ov,
-            config2,
-            action.uri,
-            withIdentity2(config2, [
-              "write",
-              action.uri,
-              "--content",
-              action.content,
-              "--mode",
-              "replace",
-              "--wait",
-              "--timeout",
-              "120"
-            ])
-          );
+          await writeMemoryFile(config2, ov, action.uri, action.content, "replace", false, { quiet: true });
           appliedMessages.push(`Updated kept memory: ${action.uri}`);
-          const output = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
-          if (output) {
-            appliedMessages.push(output);
-          }
         }
         for (const action of plan.archives) {
           const archiveResult = await archiveMemoryForCompact(config2, ov, action);
@@ -35908,22 +36012,7 @@ async function writeDurableMemory(config2, params) {
     const finalMetadata = isInPlaceUpdate ? { ...params.metadata, supersedes: void 0 } : candidateMetadata;
     const memory = isInPlaceUpdate ? formatMemoryDocument2("MEMORY", finalMetadata, params.bodyText) : candidateMemory;
     const writeMode = await memoryWriteMode(ov, config2, memoryUri, finalMetadata);
-    const result = await runOpenVikingWriteWithRetry(
-      ov,
-      config2,
-      memoryUri,
-      withIdentity2(config2, [
-        "write",
-        memoryUri,
-        "--content",
-        memory,
-        "--mode",
-        writeMode,
-        "--wait",
-        "--timeout",
-        "120"
-      ])
-    );
+    await writeMemoryFile(config2, ov, memoryUri, memory, writeMode, false, { quiet: true });
     const messages = [`Stored memory: ${memoryUri}`];
     if (params.replaceUri && !isInPlaceUpdate) {
       const removedReplacedMemory = await removeVikingResourceWithRetry(ov, config2, params.replaceUri);
@@ -35933,8 +36022,7 @@ async function writeDurableMemory(config2, params) {
     } else if (isInPlaceUpdate) {
       messages.push(`Updated existing memory in place: ${memoryUri}`);
     }
-    const text = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
-    return { content: [{ type: "text", text: [...messages, text].filter(Boolean).join("\n") }] };
+    return { content: [{ type: "text", text: messages.join("\n") }] };
   } catch (err) {
     return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
   }
@@ -35969,27 +36057,10 @@ async function writeSharedMemoryReplacement(config2, ov, params, targetUri) {
     messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} before shared update.`);
   }
   messages.push(
-    ...await gitPublishWorkflow(resolved.config.worktree, relativePath, `share: update ${relativePath}`, true)
+    ...await publishShareGitChange(resolved.config.worktree, relativePath, `share: update ${relativePath}`)
   );
   return { content: [{ type: "text", text: messages.join("\n") }] };
 }
-async function runOpenVikingWriteWithRetry(ov, config2, memoryUri, args) {
-  for (let attempt = 0; attempt < 4; attempt += 1) {
-    const result = await runCommand(ov, args, { allowFailure: true });
-    if (result.exitCode === 0) {
-      return result;
-    }
-    if (await vikingResourceExists2(ov, config2, memoryUri)) {
-      await runCommand(ov, withIdentity2(config2, ["wait", "--timeout", "120"]), { allowFailure: true });
-      return { exitCode: 0, stdout: "OpenViking accepted the memory and indexing wait completed.", stderr: "" };
-    }
-    if (!isResourceBusy(result.stderr, result.stdout) || attempt === 3) {
-      throw new Error(`${ov} ${args.join(" ")} failed: ${result.stderr || result.stdout}`);
-    }
-    await sleep(1e3 * (attempt + 1));
-  }
-  throw new Error(`${ov} ${args.join(" ")} failed.`);
-}
 async function vikingResourceExists2(ov, config2, uri) {
   const stat2 = await runCommand(ov, withIdentity2(config2, ["stat", uri]), { allowFailure: true });
   return stat2.exitCode === 0;
@@ -36011,9 +36082,9 @@ async function removeVikingResourceWithRetry(ov, config2, uri) {
   }
   return false;
 }
-function isResourceBusy(stderr, stdout) {
+function isResourceBusy(stderr, stdout2) {
   const output = `${stderr}
-${stdout}`.toLowerCase();
+${stdout2}`.toLowerCase();
   return output.includes("resource is busy") || output.includes("resource is being processed");
 }
 async function ensureMemoryDirectory(ov, config2, directoryUri) {
@@ -36217,17 +36288,27 @@ async function runSharePublishTool(config2, sourceUri, options) {
     }
     await ensureSharedDirectoryChain(config2, ov, targetUri, false);
     await writeMemoryFile(config2, ov, targetUri, content, "create", false);
+    const messages = [`Published ${sourceUri} -> ${targetUri}`];
+    for (const redaction of scrub.redactions) {
+      messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} before publish.`);
+    }
+    const relativePath = vikingUriToWorktreeRelative(config2, targetUri, resolved.name);
+    const commitMessage = options.message ?? `share: publish ${relativePath}`;
+    const gitMessages = await publishShareGitChange(resolved.config.worktree, relativePath, commitMessage, {
+      push: options.push
+    });
     try {
-      await removeWithRollback(config2, ov, sourceUri, targetUri, resolved.config.worktree, false, "publish");
+      await removeMemoryUri(config2, ov, sourceUri, false, { quiet: true });
     } catch (sourceErr) {
       return {
         content: [
           {
             type: "text",
             text: [
-              `Refused to leave a half-published state: could not remove ${sourceUri}.`,
-              `Rolled back ${targetUri} so the system is back to the pre-publish state.`,
-              `Retry the publish once OpenViking's queue settles.`,
+              ...messages,
+              ...gitMessages,
+              `Could not remove the personal source after publish: ${sourceUri}.`,
+              `Retry cleanup later with: threadnote forget ${sourceUri}`,
               sourceErr instanceof Error ? sourceErr.message : String(sourceErr)
             ].join("\n")
           }
@@ -36235,18 +36316,6 @@ async function runSharePublishTool(config2, sourceUri, options) {
         isError: true
       };
     }
-    const messages = [`Published ${sourceUri} -> ${targetUri}`];
-    for (const redaction of scrub.redactions) {
-      messages.push(`Redacted ${redaction.count}\xD7 ${redaction.name} before publish.`);
-    }
-    const relativePath = vikingUriToWorktreeRelative(config2, targetUri, resolved.name);
-    const commitMessage = options.message ?? `share: publish ${relativePath}`;
-    const gitMessages = await gitPublishWorkflow(
-      resolved.config.worktree,
-      relativePath,
-      commitMessage,
-      options.push !== false
-    );
     return {
       content: [{ type: "text", text: [...messages, ...gitMessages].join("\n") }],
       isError: false
@@ -36255,47 +36324,15 @@ async function runSharePublishTool(config2, sourceUri, options) {
     return { content: [{ type: "text", text: errorMessage(err) }], isError: true };
   }
 }
-async function gitPublishWorkflow(worktree, relativePath, commitMessage, push) {
-  const messages = [];
-  const add = await runCommand("git", ["-C", worktree, "add", relativePath], { allowFailure: true });
-  if (add.exitCode !== 0) {
-    messages.push(`git add failed: ${add.stderr.trim() || add.stdout.trim()}`);
-    return messages;
-  }
-  const commit = await runCommand("git", ["-C", worktree, "commit", "-m", commitMessage], { allowFailure: true });
-  if (commit.exitCode !== 0) {
-    const detail = commit.stdout.trim() || commit.stderr.trim();
-    if (/nothing to commit|no changes added/i.test(detail)) {
-      messages.push("git commit: nothing to commit (file already in tree)");
-    } else {
-      messages.push(`git commit failed: ${detail}`);
-      return messages;
-    }
-  } else {
-    messages.push(`git commit: ${commit.stdout.trim().split("\n").slice(0, 2).join(" ")}`);
-  }
-  if (!push) {
-    messages.push("git push skipped (push=false)");
-    return messages;
-  }
-  const pushResult = await runCommand("git", ["-C", worktree, "push", DEFAULT_GIT_REMOTE_NAME], { allowFailure: true });
-  const pushDetail = pushResult.stdout.trim() || pushResult.stderr.trim();
-  if (pushResult.exitCode !== 0) {
-    messages.push(`git push failed: ${pushDetail}`);
-  } else {
-    messages.push(`git push: ${pushDetail || "ok"}`);
-  }
-  return messages;
-}
 function withIdentity2(config2, args) {
   return [...args, "--account", config2.account, "--user", config2.user, "--agent-id", config2.agentId];
 }
 async function requiredOpenVikingCli2() {
-  const command = process.env.THREADNOTE_OV ?? await findExecutable(["ov", "openviking"]) ?? await firstExistingPath([(0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "ov"), (0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "openviking")]);
-  if (!command) {
+  const command2 = process.env.THREADNOTE_OV ?? await findExecutable(["ov", "openviking"]) ?? await firstExistingPath([(0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "ov"), (0, import_node_path4.join)((0, import_node_os3.homedir)(), ".local", "bin", "openviking")]);
+  if (!command2) {
     throw new Error("Neither ov nor openviking was found. Run threadnote install first.");
   }
-  return command;
+  return command2;
 }
 async function firstExistingPath(paths) {
   for (const path of paths) {