threadnote 1.6.1 → 1.7.0

package/dist/mcp_server.cjs

@@ -35501,6 +35501,82 @@ 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/scrubber.ts
+var SCRUBBER_PATTERNS = [
+  { name: "private key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
+  { name: "API key (sk-...)", regex: /\bsk-[A-Za-z0-9_-]{16,}/ },
+  { name: "GitHub token", regex: /\bgh[pousr]_[A-Za-z0-9_]{16,}/ },
+  { name: "GitHub fine-grained PAT", regex: /\bgithub_pat_[A-Za-z0-9_]{20,}/ },
+  { name: "GitLab PAT", regex: /\bglpat-[A-Za-z0-9_-]{20,}/ },
+  { name: "bearer token", regex: /\bBearer\s+[A-Za-z0-9._~+/=-]{20,}/i },
+  { name: "basic auth header", regex: /\bBasic\s+[A-Za-z0-9+/]{16,}={0,2}\b/i },
+  { name: "JWT", regex: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/ },
+  { name: "AWS access key", regex: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/ },
+  { name: "AWS secret access key", regex: /\baws_secret_access_key\s*[:=]\s*["']?[A-Za-z0-9/+=]{35,}["']?/i },
+  { name: "AWS session token", regex: /\baws_session_token\s*[:=]\s*["']?[A-Za-z0-9/+=]{40,}["']?/i },
+  { name: "Google API key", regex: /\bAIza[0-9A-Za-z_-]{35}\b/ },
+  { name: "Google OAuth token", regex: /\bya29\.[0-9A-Za-z_-]{20,}/ },
+  { name: "Stripe key", regex: /\b(?:sk|rk)_(?:live|test)_[0-9A-Za-z]{16,}\b/ },
+  { name: "Stripe webhook secret", regex: /\bwhsec_[0-9A-Za-z]{16,}\b/ },
+  {
+    name: "Discord token",
+    regex: /\b(?:mfa\.[A-Za-z0-9_-]{20,}|[MN][A-Za-z0-9_-]{23}\.[A-Za-z0-9_-]{6}\.[A-Za-z0-9_-]{27,})\b/
+  },
+  {
+    name: "Discord webhook",
+    regex: /https:\/\/(?:canary\.|ptb\.)?discord(?:app)?\.com\/api\/webhooks\/\d+\/[A-Za-z0-9_-]+/i
+  },
+  { name: "Slack token", regex: /\bx(?:app|ox[abcdeprs])(?:-\d-)?[A-Za-z0-9._-]{10,}/i },
+  { name: "Slack webhook", regex: /https:\/\/hooks\.slack\.com\/services\/[A-Z0-9]+\/[A-Z0-9]+\/[A-Za-z0-9]+/i },
+  {
+    name: "database URI",
+    regex: /\b(?:postgres(?:ql)?|mysql|mariadb|mongodb(?:\+srv)?|redis):\/\/[^:\s/@]+:[^@\s]+@[^\s)>"'`,]+/i
+  },
+  { name: "URL basic auth", regex: /\bhttps?:\/\/[^:\s/@]+:[^@\s]+@[^\s)>"'`,]+/i },
+  { name: "macOS home path", placeholder: "<local-path>", regex: /\/Users\/[^\s)>"'`,]+/ },
+  { name: "linux home path", placeholder: "<local-path>", regex: /\/home\/[^\s)>"'`,]+/ }
+];
+function applyScrubber(content, { redact }) {
+  let cleaned = content;
+  const redactions = [];
+  for (const pattern of SCRUBBER_PATTERNS) {
+    if (!pattern.regex.test(cleaned)) {
+      continue;
+    }
+    if (!pattern.placeholder || !redact) {
+      return { blocker: pattern.name, cleaned: content, redactions: [] };
+    }
+    const globalRegex = globalize(pattern.regex);
+    const matches = cleaned.match(globalRegex) ?? [];
+    cleaned = cleaned.replace(globalRegex, pattern.placeholder);
+    redactions.push({ count: matches.length, name: pattern.name });
+  }
+  return { cleaned, redactions };
+}
+function credentialScrubberBlocker(content) {
+  for (const pattern of SCRUBBER_PATTERNS) {
+    if (pattern.placeholder === void 0 && pattern.regex.test(content)) {
+      return pattern.name;
+    }
+  }
+  return void 0;
+}
+function redactSensitiveText(content) {
+  let redacted = content.replace(
+    /([A-Za-z0-9_.-]*(?:token|secret|password|api[_-]?key|authorization|credential|session)[A-Za-z0-9_.-]*\s*[:=]\s*)("[^"]+"|'[^']+'|Bearer\s+[^'"\s]+|\S+)/gi,
+    "$1[REDACTED]"
+  );
+  for (const pattern of SCRUBBER_PATTERNS) {
+    const placeholder = pattern.placeholder ?? "<secret>";
+    redacted = redacted.replace(globalize(pattern.regex), placeholder);
+  }
+  return redacted;
+}
+function globalize(regex) {
+  const flags = regex.flags.includes("g") ? regex.flags : `${regex.flags}g`;
+  return new RegExp(regex.source, flags);
+}
+
 // src/utils.ts
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -35514,10 +35590,24 @@ function parseJsonConfigObject(content) {
   }
 }
 function redactText(content) {
-  return content.replace(
-    /([A-Za-z0-9_.-]*(?:token|secret|password|api[_-]?key|authorization)[A-Za-z0-9_.-]*\s*[:=]\s*)("[^"]+"|'[^']+'|Bearer\s+[^'"\s]+|\S+)/gi,
-    "$1[REDACTED]"
-  ).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]");
+  return redactSensitiveText(content);
+}
+var GIT_ENVIRONMENT_KEYS = [
+  "GIT_DIR",
+  "GIT_WORK_TREE",
+  "GIT_INDEX_FILE",
+  "GIT_PREFIX",
+  "GIT_COMMON_DIR",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+  "GIT_QUARANTINE_PATH"
+];
+function withoutGitEnvironment(env = process.env) {
+  const next = { ...env };
+  for (const key of GIT_ENVIRONMENT_KEYS) {
+    delete next[key];
+  }
+  return next;
 }
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -35638,6 +35728,7 @@ async function runCommand(executable, args, options = {}) {
       {
         cwd: options.cwd,
         encoding: "utf8",
+        env: commandEnvironment(executable, options.env),
         maxBuffer: maxOutputBytes
       },
       (err, stdout2, stderr) => {
@@ -35677,6 +35768,12 @@ async function runCommand(executable, args, options = {}) {
     }
   });
 }
+function commandEnvironment(executable, env) {
+  if ((0, import_node_path.basename)(executable) !== "git") {
+    return env;
+  }
+  return withoutGitEnvironment(env ?? process.env);
+}
 function commandResultFromExecFileCallback(params) {
   if (params.failureMessage) {
     return { exitCode: 124, stderr: params.failureMessage, stdout: params.stdout };
@@ -35713,6 +35810,64 @@ async function gitValue(args, cwd = getInvocationCwd()) {
   }
   return result.stdout.trim();
 }
+async function resolveRepoName(cwd = getInvocationCwd()) {
+  const repoRoot = await gitValue(["rev-parse", "--show-toplevel"], cwd);
+  if (!repoRoot) {
+    return void 0;
+  }
+  const remoteName = await resolveGitRemoteRepoName(repoRoot);
+  if (remoteName) {
+    return remoteName;
+  }
+  return resolveRepoFolderName(repoRoot);
+}
+async function resolveRepoFolderName(cwd = getInvocationCwd()) {
+  const repoRoot = await gitValue(["rev-parse", "--show-toplevel"], cwd);
+  if (!repoRoot) {
+    return void 0;
+  }
+  const commonDir = await gitValue(["rev-parse", "--git-common-dir"], repoRoot);
+  if (commonDir) {
+    const absoluteCommonDir = (0, import_node_path.isAbsolute)(commonDir) ? commonDir : (0, import_node_path.resolve)(repoRoot, commonDir);
+    const primaryRoot = (0, import_node_path.basename)(absoluteCommonDir) === ".git" ? (0, import_node_path.dirname)(absoluteCommonDir) : absoluteCommonDir;
+    const name = (0, import_node_path.basename)(primaryRoot).replace(/\.git$/, "");
+    if (name && name !== ".") {
+      return name;
+    }
+  }
+  return (0, import_node_path.basename)(repoRoot);
+}
+async function resolveGitRemoteRepoName(repoRoot) {
+  const originUrl = await gitValue(["remote", "get-url", "origin"], repoRoot);
+  const originName = originUrl ? gitRemoteRepoName(originUrl) : void 0;
+  if (originName) {
+    return originName;
+  }
+  const remotes = await gitValue(["remote"], repoRoot);
+  const remote = remotes?.split(/\r?\n/).map((name) => name.trim()).find((name) => name.length > 0);
+  if (!remote) {
+    return void 0;
+  }
+  const remoteUrl = await gitValue(["remote", "get-url", remote], repoRoot);
+  return remoteUrl ? gitRemoteRepoName(remoteUrl) : void 0;
+}
+function gitRemoteRepoName(remoteUrl) {
+  const trimmed = remoteUrl.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  let remotePath = trimmed.replace(/[?#].*$/, "");
+  try {
+    remotePath = new URL(trimmed).pathname;
+  } catch (_err) {
+    const scpLike = trimmed.match(/^[^@\s/]+@[^:\s]+:(.+)$/);
+    if (scpLike?.[1]) {
+      remotePath = scpLike[1];
+    }
+  }
+  const name = remotePath.replace(/[\\/]+$/, "").split(/[\\/:]/).filter(Boolean).pop()?.replace(/\.git$/i, "");
+  return name && name !== "." && name !== ".." ? name : void 0;
+}
 async function sleep(ms) {
   return new Promise((resolvePromise) => {
     setTimeout(resolvePromise, ms);
@@ -35853,6 +36008,13 @@ async function enrichRecallQueryWithWorkspaceContext(query, options = {}) {
 async function enrichRecallQueryWithWorkspaceProjectContext(query, options = {}) {
   return enrichRecallQueryWithWorkspaceTerms(query, options, false);
 }
+async function resolveWorkspaceRepoName(options = {}) {
+  const cwd = options.cwd ?? (options.includeProcessCwd === false ? void 0 : getInvocationCwd());
+  if (!cwd || !(0, import_node_path.isAbsolute)(cwd)) {
+    return void 0;
+  }
+  return resolveRepoName(cwd);
+}
 async function enrichRecallQueryWithWorkspaceTerms(query, options, includeBranch) {
   if (!recallQueryRequestsWorkspaceContext(query)) {
     return query;
@@ -35871,10 +36033,11 @@ async function currentWorkspaceRecallTerms(options, includeBranch) {
     return [];
   }
   const branch = await gitValue(["branch", "--show-current"], repoRoot);
+  const repoName = await resolveWorkspaceRepoName({ cwd, includeProcessCwd: false });
   const parent = (0, import_node_path.dirname)(repoRoot);
   return uniqueUsefulWorkspaceTerms([
     { source: "branch", value: includeBranch ? branch : void 0 },
-    { source: "path", value: (0, import_node_path.basename)(repoRoot) },
+    { source: "path", value: repoName },
     { source: "path", value: parent === (0, import_node_os.homedir)() ? void 0 : (0, import_node_path.basename)(parent) }
   ]);
 }
@@ -36778,53 +36941,6 @@ var PACK_FILES_DIR = "files";
 var PACK_ROOT_TOKEN = "${THREADNOTE_PACK_ROOT}";
 var AUTO_SHARE_FETCH_INTERVAL_MS = 5 * 60 * 1e3;
 var DEFAULT_GIT_REMOTE_NAME = "origin";
-var SCRUBBER_PATTERNS = [
-  // Credentials: never redactable. Blocking is the only safe response —
-  // automated redaction risks false negatives that leave material in git.
-  { name: "private key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
-  { name: "API key (sk-...)", regex: /\bsk-[A-Za-z0-9_-]{16,}/ },
-  { name: "GitHub token", regex: /\bgh[pousr]_[A-Za-z0-9_]{16,}/ },
-  { name: "GitHub fine-grained PAT", regex: /\bgithub_pat_[A-Za-z0-9_]{20,}/ },
-  { name: "GitLab PAT", regex: /\bglpat-[A-Za-z0-9_-]{20,}/ },
-  { name: "bearer token", regex: /\bBearer\s+[A-Za-z0-9._~+/=-]{20,}/i },
-  // Matches bare JWTs (three base64url segments). May surface a JWE token in
-  // legitimate docs; if that becomes noisy we can switch to warn-only.
-  { name: "JWT", regex: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/ },
-  { name: "AWS access key", regex: /\bAKIA[0-9A-Z]{16}\b/ },
-  // Slack tokens: xoxa/xoxb/xoxc (configuration)/xoxd (legacy user cookie)/
-  // xoxe (refresh)/xoxp/xoxr/xoxs, with optional -N- segment for the workspace tier.
-  { name: "Slack token", regex: /\bxox[abcdeprs](?:-\d-)?[A-Za-z0-9._-]{10,}/i },
-  // Soft leaks: block by default (so the agent sees them and decides), but
-  // allow opt-in redaction so curated memories with incidental matches can
-  // ship without a manual rewrite. Local home paths are the recurring
-  // real-world leak; the regexes greedily consume the whole path segment
-  // (including subdirectories) up to whitespace or common closing punctuation
-  // so redaction collapses an entire path to a single placeholder rather than
-  // leaving the subpath visible.
-  { name: "macOS home path", placeholder: "<local-path>", regex: /\/Users\/[^\s)>"'`,]+/ },
-  // No leading \b: it only matches when a word char precedes the slash, which
-  // misses the common cases (after =, :, whitespace, or line start). Mirror the
-  // macOS pattern so /home/... is caught in every position.
-  { name: "linux home path", placeholder: "<local-path>", regex: /\/home\/[^\s)>"'`,]+/ }
-];
-function applyScrubber(content, { redact }) {
-  let cleaned = content;
-  const redactions = [];
-  for (const pattern of SCRUBBER_PATTERNS) {
-    if (!pattern.regex.test(cleaned)) {
-      continue;
-    }
-    if (!pattern.placeholder || !redact) {
-      return { blocker: pattern.name, cleaned: content, redactions: [] };
-    }
-    const flags = pattern.regex.flags.includes("g") ? pattern.regex.flags : `${pattern.regex.flags}g`;
-    const globalRegex = new RegExp(pattern.regex.source, flags);
-    const matches = cleaned.match(globalRegex) ?? [];
-    cleaned = cleaned.replace(globalRegex, pattern.placeholder);
-    redactions.push({ count: matches.length, name: pattern.name });
-  }
-  return { cleaned, redactions };
-}
 var autoShareStates = /* @__PURE__ */ new Map();
 function startShareBackgroundFetch(config2) {
   const state = autoShareState(config2);
@@ -37053,7 +37169,7 @@ async function publishShareGitChange(worktree, relativePath, commitMessage, opti
   const git = await requiredExecutable("git");
   const messages = [];
   const paths = typeof relativePath === "string" ? [relativePath] : [...relativePath];
-  const stageArgs = verb === "rm" ? ["-C", worktree, "rm", ...paths] : ["-C", worktree, "add", "--", ...paths];
+  const stageArgs = verb === "rm" ? ["-C", worktree, "rm", "--", ...paths] : ["-C", worktree, "add", "--", ...paths];
   const stageResult = await runGitCommand(dryRun, git, stageArgs, `git ${verb} failed`);
   if (stageResult) {
     messages.push(`git ${verb}: ${stageResult.stdout.trim() || "ok"}`);
@@ -37396,13 +37512,7 @@ function isProbablyBinary(buffer) {
   }
 }
 function detectBinaryCredential(buffer) {
-  const latin1 = buffer.toString("latin1");
-  for (const pattern of SCRUBBER_PATTERNS) {
-    if (pattern.placeholder === void 0 && pattern.regex.test(latin1)) {
-      return pattern.name;
-    }
-  }
-  return void 0;
+  return credentialScrubberBlocker(buffer.toString("latin1"));
 }
 function detectBinaryLocalPath(buffer, rewriteRoots) {
   const latin1 = buffer.toString("latin1");
@@ -38653,6 +38763,18 @@ function stripPersonalProvenance(content) {
   }
   return cleaned.join("\n");
 }
+async function readMemoryContent(config2, ov, uri, dryRun) {
+  const args = withIdentity(config2, ["read", uri]);
+  if (dryRun) {
+    console.log(`Would run: ${formatShellCommand(ov, args)}`);
+    return "<dry-run memory body>";
+  }
+  const result = await runCommand(ov, args);
+  if (!result.stdout.trim()) {
+    throw new Error(`Refusing to publish empty memory at ${uri}`);
+  }
+  return result.stdout;
+}
 async function ensureSharedDirectoryChain(config2, ov, memoryUri, dryRun, options = {}) {
   const directoryUri = parentUri(memoryUri);
   for (const uri of sharedDirectoryChain(config2, directoryUri)) {
@@ -38810,9 +38932,19 @@ function isResourceBusyFailure(stderr, stdout2) {
 ${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_promises4.readFile)(filePath, "utf8");
-  await writeMemoryFile(config2, ov, uri, content, initialMode, false, options);
+async function readSharedInboundFileContent(uri, filePath) {
+  if (!await isRegularFileNoSymlink(filePath)) {
+    throw new Error(`Refusing to ingest non-regular shared file: ${filePath}`);
+  }
+  return prepareSharedInboundContent(uri, await (0, import_promises4.readFile)(filePath, "utf8"));
+}
+function prepareSharedInboundContent(uri, rawContent) {
+  const stripped = stripPersonalProvenance(rawContent);
+  const scrub = applyScrubber(stripped, { redact: false });
+  if (scrub.blocker) {
+    throw new Error(`Refusing to ingest ${uri}: possible ${scrub.blocker}. Strip the sensitive value upstream first.`);
+  }
+  return scrub.cleaned;
 }
 async function removeMemoryUri(config2, ov, uri, dryRun, options = {}) {
   const args = withIdentity(config2, ["rm", uri]);
@@ -38860,8 +38992,10 @@ async function gitOutput(worktree, args, dryRun) {
   }
   return result.stdout.trim();
 }
+var GIT_MODE_ABSENT = "000000";
+var GIT_MODE_SYMLINK = "120000";
 async function listChangedFiles(worktree, beforeRev, afterRev) {
-  const result = await runCommand("git", ["-C", worktree, "diff", "--name-status", "-z", `${beforeRev}..${afterRev}`], {
+  const result = await runCommand("git", ["-C", worktree, "diff", "--raw", "-z", `${beforeRev}..${afterRev}`], {
     allowFailure: true
   });
   if (result.exitCode !== 0) {
@@ -38870,27 +39004,65 @@ async function listChangedFiles(worktree, beforeRev, afterRev) {
   const entries = result.stdout.split("\0").filter((part) => part.length > 0);
   const changes = [];
   for (let index = 0; index < entries.length; ) {
-    const raw = entries[index];
-    const head = raw.slice(0, 1);
+    const raw = entries[index++];
+    const match = raw.match(/^:(\d{6}) (\d{6}) [0-9a-f]+ [0-9a-f]+ ([A-Z])\d*/);
+    if (!match) {
+      continue;
+    }
+    const [, oldMode, newMode, head] = match;
     if (head === "R" || head === "C") {
-      const oldRel = entries[index + 1];
-      const newRel = entries[index + 2];
-      if (oldRel && newRel) {
-        changes.push({ path: (0, import_node_path3.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
+      const oldRel = entries[index];
+      const newRel = entries[index + 1];
+      if (oldRel) {
+        changes.push({
+          path: (0, import_node_path3.join)(worktree, oldRel),
+          previousContent: oldMode === GIT_MODE_SYMLINK ? void 0 : await gitFileContent(worktree, beforeRev, oldRel),
+          relativePath: oldRel,
+          status: "removed"
+        });
+      }
+      if (newRel && newMode !== GIT_MODE_SYMLINK) {
         changes.push({ path: (0, import_node_path3.join)(worktree, newRel), relativePath: newRel, status: "added" });
       }
-      index += 3;
+      index += 2;
       continue;
     }
-    const rel = entries[index + 1];
+    const rel = entries[index];
     if (rel) {
-      const status = head === "A" ? "added" : head === "D" ? "removed" : "modified";
-      changes.push({ path: (0, import_node_path3.join)(worktree, rel), relativePath: rel, status });
+      if (head === "D") {
+        changes.push({
+          path: (0, import_node_path3.join)(worktree, rel),
+          previousContent: oldMode === GIT_MODE_SYMLINK ? void 0 : await gitFileContent(worktree, beforeRev, rel),
+          relativePath: rel,
+          status: "removed"
+        });
+      } else if (newMode === GIT_MODE_SYMLINK) {
+        if (oldMode !== GIT_MODE_ABSENT) {
+          changes.push({
+            path: (0, import_node_path3.join)(worktree, rel),
+            previousContent: oldMode === GIT_MODE_SYMLINK ? void 0 : await gitFileContent(worktree, beforeRev, rel),
+            relativePath: rel,
+            status: "removed"
+          });
+        }
+      } else {
+        const status = head === "A" ? "added" : "modified";
+        changes.push({
+          path: (0, import_node_path3.join)(worktree, rel),
+          previousContent: oldMode === GIT_MODE_ABSENT || oldMode === GIT_MODE_SYMLINK ? void 0 : await gitFileContent(worktree, beforeRev, rel),
+          relativePath: rel,
+          status
+        });
+      }
     }
-    index += 2;
+    index += 1;
   }
   return changes;
 }
+async function gitFileContent(worktree, rev, relativePath) {
+  const result = await runCommand("git", ["-C", worktree, "show", `${rev}:${relativePath}`], { allowFailure: true });
+  return result.exitCode === 0 ? result.stdout : void 0;
+}
 async function applyChangesToOpenViking(config2, team, changes, options = {}) {
   const ov = await openVikingCliForMode(false);
   const failed = [];
@@ -38905,22 +39077,37 @@ async function applyChangesToOpenViking(config2, team, changes, options = {}) {
     const uri = workfileToVikingUri(config2, team, change.path);
     try {
       if (change.status === "removed") {
+        const currentContent2 = await readExistingMemoryContent(config2, ov, uri);
+        if (currentContent2 === void 0) {
+          continue;
+        }
+        assertInboundPreviousContentMatches(change, uri, currentContent2);
         await removeMemoryUri(config2, ov, uri, false, options);
         continue;
       }
-      if (!await isFile(change.path)) {
+      if (!await isRegularFileNoSymlink(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)";
+      const content = await readSharedInboundFileContent(uri, change.path);
+      const currentContent = await readExistingMemoryContent(config2, ov, uri);
+      if (currentContent !== void 0) {
+        if (change.status === "added") {
+          if (currentContent === content) {
+            continue;
+          }
+          throw new Error(
+            `Refusing to ingest newly added shared file over existing local OpenViking resource ${uri}; inspect and resolve the local edit first.`
+          );
+        }
+        assertInboundPreviousContentMatches(change, uri, currentContent);
+        const reason = change.status === "modified" ? "updating from upstream after verifying local content matches the previous shared version" : "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);
+      const writeMode = currentContent !== void 0 ? "replace" : "create";
+      await writeMemoryFile(config2, ov, uri, content, writeMode, false, options);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       if (options.quiet !== true) {
@@ -38931,6 +39118,25 @@ async function applyChangesToOpenViking(config2, team, changes, options = {}) {
   }
   return { failed };
 }
+async function readExistingMemoryContent(config2, ov, uri) {
+  if (!await vikingResourceExists(ov, config2, uri)) {
+    return void 0;
+  }
+  return readMemoryContent(config2, ov, uri, false);
+}
+function assertInboundPreviousContentMatches(change, uri, currentContent) {
+  if (change.previousContent === void 0) {
+    throw new Error(
+      `Refusing to apply inbound shared change for ${uri}: previous shared content is unavailable, so local edits cannot be distinguished from upstream edits.`
+    );
+  }
+  const expectedContent = prepareSharedInboundContent(uri, change.previousContent);
+  if (currentContent !== expectedContent) {
+    throw new Error(
+      `Refusing to apply inbound shared change for ${uri}: local OpenViking content differs from the previous shared version. Inspect and resolve the local edit first.`
+    );
+  }
+}
 function mergeChanges(...lists) {
   const map2 = /* @__PURE__ */ new Map();
   for (const list of lists) {
@@ -39659,6 +39865,10 @@ function registerTools(server, config2) {
       if (!checkedPattern.ok) {
         return checkedPattern.error;
       }
+      const checkedLiteralPattern = rejectLeadingDash(checkedPattern.value, "grep", "pattern");
+      if (!checkedLiteralPattern.ok) {
+        return checkedLiteralPattern.error;
+      }
       const checkedUri = optionalVikingUri(uri, "grep");
       if (!checkedUri.ok) {
         return checkedUri.error;
@@ -39666,7 +39876,7 @@ function registerTools(server, config2) {
       return runOpenVikingMcpTool(config2, "grep", {
         case_insensitive: caseInsensitive ?? case_insensitive,
         node_limit: nodeLimit ?? node_limit,
-        pattern: checkedPattern.value,
+        pattern: checkedLiteralPattern.value,
         uri: checkedUri.value ?? `viking://user/${uriSegment2(config2.user)}/memories`
       });
     }
@@ -39688,13 +39898,17 @@ function registerTools(server, config2) {
       if (!checkedPattern.ok) {
         return checkedPattern.error;
       }
+      const checkedLiteralPattern = rejectLeadingDash(checkedPattern.value, "glob", "pattern");
+      if (!checkedLiteralPattern.ok) {
+        return checkedLiteralPattern.error;
+      }
       const checkedUri = optionalVikingUri(uri, "glob");
       if (!checkedUri.ok) {
         return checkedUri.error;
       }
       return runOpenVikingMcpTool(config2, "glob", {
         node_limit: nodeLimit ?? node_limit,
-        pattern: checkedPattern.value,
+        pattern: checkedLiteralPattern.value,
         uri: checkedUri.value
       });
     }
@@ -40007,6 +40221,10 @@ function registerOpenVikingParityTools(server, config2) {
       if (!checkedPattern.ok) {
         return checkedPattern.error;
       }
+      const checkedLiteralPattern = rejectLeadingDash(checkedPattern.value, "ov_grep", "pattern");
+      if (!checkedLiteralPattern.ok) {
+        return checkedLiteralPattern.error;
+      }
       const checkedUri = optionalVikingUri(uri, "ov_grep");
       if (!checkedUri.ok) {
         return checkedUri.error;
@@ -40014,7 +40232,7 @@ function registerOpenVikingParityTools(server, config2) {
       return runOpenVikingMcpTool(config2, "grep", {
         case_insensitive: caseInsensitive ?? case_insensitive,
         node_limit: nodeLimit ?? node_limit,
-        pattern: checkedPattern.value,
+        pattern: checkedLiteralPattern.value,
         uri: checkedUri.value
       });
     }
@@ -40036,13 +40254,17 @@ function registerOpenVikingParityTools(server, config2) {
       if (!checkedPattern.ok) {
         return checkedPattern.error;
       }
+      const checkedLiteralPattern = rejectLeadingDash(checkedPattern.value, "ov_glob", "pattern");
+      if (!checkedLiteralPattern.ok) {
+        return checkedLiteralPattern.error;
+      }
       const checkedUri = optionalVikingUri(uri, "ov_glob");
       if (!checkedUri.ok) {
         return checkedUri.error;
       }
       return runOpenVikingMcpTool(config2, "glob", {
         node_limit: nodeLimit ?? node_limit,
-        pattern: checkedPattern.value,
+        pattern: checkedLiteralPattern.value,
         uri: checkedUri.value
       });
     }
@@ -40243,6 +40465,7 @@ async function runRecallTool(config2, params) {
     indexRepairMessages = [`Auto-index repair warning: ${errorMessage(err)}`];
   }
   const project = params.pinnedUri ? void 0 : await inferProjectFromQuery(config2.manifestPath, projectQuery);
+  const projectMemoryName = params.pinnedUri ? void 0 : await resolveWorkspaceRepoName({ cwd: params.callerCwd, includeProcessCwd: false });
   const limitArgs = params.nodeLimit ? ["--node-limit", String(params.nodeLimit)] : [];
   const threshold = params.threshold ?? RECALL_SCORE_THRESHOLD;
   const explicitWorkset = params.workset ? await requireWorkset(config2.manifestPath, params.workset) : void 0;
@@ -40254,6 +40477,19 @@ async function runRecallTool(config2, params) {
     params.includeArchived
   );
   const passes = [base.hits];
+  const scopedRecallUris = new Set([params.pinnedUri].filter((uri) => uri !== void 0));
+  for (const scope of projectMemoryScopeUris(config2, projectMemoryName, params.includeArchived)) {
+    if (!scopedRecallUris.has(scope)) {
+      scopedRecallUris.add(scope);
+      const projectMemoryPass = await recallSearchHits(
+        config2,
+        ["search", query, "--uri", scope, ...limitArgs],
+        threshold,
+        params.includeArchived
+      );
+      passes.push(projectMemoryPass.hits);
+    }
+  }
   const seededUri = project ? trimTrailingSlash(project.uri) : void 0;
   if (seededUri?.startsWith("viking://") && seededUri !== params.pinnedUri) {
     const seeded = await recallSearchHits(
@@ -40268,7 +40504,9 @@ async function runRecallTool(config2, params) {
   const workset = params.pinnedUri ? void 0 : explicitWorkset ? explicitWorkset : await inferWorksetFromQuery(config2.manifestPath, projectQuery);
   if (workset && workset.projects.length > 0) {
     sections.push(`Workset scope: ${workset.name} (${workset.projects.map((member) => member.name).join(", ")})`);
-    const alreadyScoped = new Set([params.pinnedUri, seededUri].filter((uri) => uri !== void 0));
+    const alreadyScoped = new Set(
+      [params.pinnedUri, seededUri, ...scopedRecallUris].filter((uri) => uri !== void 0)
+    );
     const worksetScopes = worksetScopeUris(config2, workset).filter((uri) => !alreadyScoped.has(uri)).slice(0, MAX_WORKSET_PASSES);
     for (const scope of worksetScopes) {
       const worksetPass = await recallSearchHits(
@@ -40955,6 +41193,24 @@ function worksetScopeUris(config2, workset) {
   }
   return [...new Set(scopes)];
 }
+function projectMemoryScopeUris(config2, projectName, includeArchived) {
+  if (!projectName) {
+    return [];
+  }
+  const base = `viking://user/${uriSegment2(config2.user)}/memories`;
+  const projectSegment = uriSegment2(projectName);
+  const scopes = [
+    `${base}/durable/projects/${projectSegment}`,
+    `${base}/handoffs/active/${projectSegment}`,
+    `${base}/incidents/active/${projectSegment}`
+  ];
+  return includeArchived ? [
+    ...scopes,
+    `${base}/durable/archived/${projectSegment}`,
+    `${base}/handoffs/archived/${projectSegment}`,
+    `${base}/incidents/archived/${projectSegment}`
+  ] : scopes;
+}
 function formatMemoryDocument2(title, metadata, body) {
   const header = [
     title,
@@ -40994,6 +41250,17 @@ function requiredText(value, toolName, fieldName, example) {
     ok: false
   };
 }
+function rejectLeadingDash(value, toolName, fieldName) {
+  if (!value.startsWith("-")) {
+    return { ok: true, value };
+  }
+  return {
+    error: argumentError(
+      `Threadnote MCP tool "${toolName}" rejects "${fieldName}" values that start with "-". Prefix relative file paths with "./" or use an absolute path.`
+    ),
+    ok: false
+  };
+}
 function requiredVikingUri(value, toolName, exampleUri) {
   const checked = requiredText(value, toolName, "uri", { uri: exampleUri });
   if (!checked.ok) {
@@ -41078,6 +41345,12 @@ async function runOpenVikingAddResourceTool(config2, toolName, params) {
       ].join("\n")
     );
   }
+  if (source) {
+    const checkedSource = rejectLeadingDash(source, toolName, "path");
+    if (!checkedSource.ok) {
+      return checkedSource.error;
+    }
+  }
   if (tempFileId) {
     const checkedTo2 = optionalVikingUri(params.to, toolName);
     if (!checkedTo2.ok) {