threadnote 1.6.1 → 1.7.0

package/dist/threadnote.cjs

@@ -3576,6 +3576,91 @@ function startProgress(message) {
   };
 }
 
+// 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 detectSecretMatches(content) {
+  const matches = [];
+  for (const pattern of SCRUBBER_PATTERNS) {
+    if (pattern.regex.test(content)) {
+      matches.push(pattern.name);
+    }
+  }
+  return matches;
+}
+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);
@@ -3589,10 +3674,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;
 }
 async function walkFiles(root) {
   const files = [];
@@ -3781,6 +3880,7 @@ async function runCommand(executable, args, options = {}) {
       {
         cwd: options.cwd,
         encoding: "utf8",
+        env: commandEnvironment(executable, options.env),
         maxBuffer: maxOutputBytes
       },
       (err, stdout2, stderr) => {
@@ -3820,6 +3920,12 @@ async function runCommand(executable, args, options = {}) {
     }
   });
 }
+function commandEnvironment(executable, env) {
+  if ((0, import_node_path2.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 };
@@ -3857,6 +3963,17 @@ 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;
@@ -3872,6 +3989,37 @@ async function resolveRepoName(cwd = getInvocationCwd()) {
   }
   return (0, import_node_path2.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 runInteractive(executable, args) {
   return new Promise((resolvePromise) => {
     const child = (0, import_node_child_process2.spawn)(executable, args, { stdio: "inherit" });
@@ -4141,6 +4289,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_path2.isAbsolute)(cwd)) {
+    return void 0;
+  }
+  return resolveRepoName(cwd);
+}
 async function enrichRecallQueryWithWorkspaceTerms(query, options, includeBranch) {
   if (!recallQueryRequestsWorkspaceContext(query)) {
     return query;
@@ -4159,10 +4314,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_path2.dirname)(repoRoot);
   return uniqueUsefulWorkspaceTerms([
     { source: "branch", value: includeBranch ? branch : void 0 },
-    { source: "path", value: (0, import_node_path2.basename)(repoRoot) },
+    { source: "path", value: repoName },
     { source: "path", value: parent === (0, import_node_os.homedir)() ? void 0 : (0, import_node_path2.basename)(parent) }
   ]);
 }
@@ -5169,9 +5325,6 @@ function existsSyncDirectory(path2) {
 var import_promises6 = require("node:fs/promises");
 var import_node_path8 = require("node:path");
 
-// src/manifest.ts
-var import_promises3 = require("node:fs/promises");
-
 // node_modules/js-yaml/dist/js-yaml.mjs
 var __create2 = Object.create;
 var __defProp2 = Object.defineProperty;
@@ -7535,6 +7688,7 @@ var { Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, l
 var index_vite_proxy_tmp_default = import_js_yaml.default;
 
 // src/manifest.ts
+var import_promises3 = require("node:fs/promises");
 function uriSegment(value) {
   const normalized = value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return normalized.length > 0 ? normalized : "unknown";
@@ -8469,53 +8623,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();
 async function runShareInit(config, remoteUrl, options) {
   if (!remoteUrl.trim()) {
@@ -8538,7 +8645,15 @@ async function runShareInit(config, remoteUrl, options) {
   await ensureDirectory((0, import_node_path7.dirname)(worktree), dryRun);
   await ensureDirectory((0, import_node_path7.dirname)(gitdir), dryRun);
   const git = await requiredExecutable("git");
-  await maybeRun(dryRun, git, ["clone", `--separate-git-dir=${gitdir}`, "--", remoteUrl, worktree]);
+  await maybeRun(dryRun, git, [
+    "clone",
+    "-c",
+    "core.symlinks=false",
+    `--separate-git-dir=${gitdir}`,
+    "--",
+    remoteUrl,
+    worktree
+  ]);
   const newConfig = {
     addedAt: (/* @__PURE__ */ new Date()).toISOString(),
     gitdir,
@@ -8972,7 +9087,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"}`);
@@ -9386,13 +9501,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");
@@ -10067,7 +10176,7 @@ async function runShareSetUrl(config, remoteUrl, options) {
   const git = await requiredExecutable("git");
   if (dryRun) {
     console.log(
-      `Would run: ${formatShellCommand(git, ["-C", team.config.worktree, "remote", "set-url", DEFAULT_GIT_REMOTE_NAME, remoteUrl])}`
+      `Would run: ${formatShellCommand(git, ["-C", team.config.worktree, "remote", "set-url", DEFAULT_GIT_REMOTE_NAME, "--", remoteUrl])}`
     );
     console.log(
       `Would run: ${formatShellCommand(git, ["-C", team.config.worktree, "fetch", DEFAULT_GIT_REMOTE_NAME])}`
@@ -10075,7 +10184,7 @@ async function runShareSetUrl(config, remoteUrl, options) {
     console.log(`Would write teams file: ${teamsFilePath(config)}`);
     return;
   }
-  await runCommand(git, ["-C", team.config.worktree, "remote", "set-url", DEFAULT_GIT_REMOTE_NAME, remoteUrl]);
+  await runCommand(git, ["-C", team.config.worktree, "remote", "set-url", DEFAULT_GIT_REMOTE_NAME, "--", remoteUrl]);
   await runCommand(git, ["-C", team.config.worktree, "fetch", DEFAULT_GIT_REMOTE_NAME]);
   const teamsFile = await readTeamsFile(config);
   const updatedTeam = { ...team.config, remote: remoteUrl };
@@ -10383,8 +10492,8 @@ function vikingUriToWorktreeRelative(config, uri, team) {
 }
 async function isRegularFileNoSymlink(path2) {
   try {
-    const stat6 = await (0, import_promises5.lstat)(path2);
-    return stat6.isFile();
+    const stat5 = await (0, import_promises5.lstat)(path2);
+    return stat5.isFile();
   } catch (_err) {
     return false;
   }
@@ -11123,9 +11232,23 @@ ${stdout2}`.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_promises5.readFile)(filePath, "utf8");
+  const content = await readSharedInboundFileContent(uri, filePath);
   await writeMemoryFile(config, 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_promises5.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(config, ov, uri, dryRun, options = {}) {
   const args = withIdentity(config, ["rm", uri]);
   if (dryRun) {
@@ -11172,8 +11295,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) {
@@ -11182,27 +11307,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_path7.join)(worktree, oldRel), relativePath: oldRel, status: "removed" });
+      const oldRel = entries[index];
+      const newRel = entries[index + 1];
+      if (oldRel) {
+        changes.push({
+          path: (0, import_node_path7.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_path7.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_path7.join)(worktree, rel), relativePath: rel, status });
+      if (head === "D") {
+        changes.push({
+          path: (0, import_node_path7.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_path7.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_path7.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(config, team, changes, options = {}) {
   const ov = await openVikingCliForMode(false);
   const failed = [];
@@ -11217,22 +11380,37 @@ async function applyChangesToOpenViking(config, team, changes, options = {}) {
     const uri = workfileToVikingUri(config, team, change.path);
     try {
       if (change.status === "removed") {
+        const currentContent2 = await readExistingMemoryContent(config, ov, uri);
+        if (currentContent2 === void 0) {
+          continue;
+        }
+        assertInboundPreviousContentMatches(change, uri, currentContent2);
         await removeMemoryUri(config, ov, uri, false, options);
         continue;
       }
-      if (!await isFile(change.path)) {
+      if (!await isRegularFileNoSymlink(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)";
+      const content = await readSharedInboundFileContent(uri, change.path);
+      const currentContent = await readExistingMemoryContent(config, 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(config, ov, uri, false, options);
-      const writeMode = ovHasResource ? "replace" : "create";
-      await ingestSingleFile(ov, config, uri, change.path, writeMode, options);
+      const writeMode = currentContent !== void 0 ? "replace" : "create";
+      await writeMemoryFile(config, ov, uri, content, writeMode, false, options);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       if (options.quiet !== true) {
@@ -11243,6 +11421,25 @@ async function applyChangesToOpenViking(config, team, changes, options = {}) {
   }
   return { failed };
 }
+async function readExistingMemoryContent(config, ov, uri) {
+  if (!await vikingResourceExists(ov, config, uri)) {
+    return void 0;
+  }
+  return readMemoryContent(config, 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 map = /* @__PURE__ */ new Map();
   for (const list of lists) {
@@ -11433,6 +11630,263 @@ async function runMigrateLifecycle(config, options) {
     ].filter((part) => part !== void 0).join("; ")
   );
 }
+async function runMigrateProjectNames(config, options) {
+  const dryRun = options.dryRun === true || options.apply !== true;
+  const limit = options.limit ? parsePositiveInteger(options.limit, "project-name migration limit") : void 0;
+  const context = await projectNameMigrationContext();
+  if (!context) {
+    console.log("No git remote project-name change applies in the current workspace.");
+    return;
+  }
+  const candidates = await projectNameMigrationCandidates(config, context, limit);
+  const seedManifestCandidate = await hasSeedManifestProjectNameMigrationCandidate(config, context);
+  if (candidates.length === 0 && !seedManifestCandidate) {
+    console.log(`No project-name migration candidates found for ${context.oldProject} -> ${context.newProject}.`);
+    return;
+  }
+  const seedManifestUpdated = await migrateSeedManifestProjectName(config, context, dryRun);
+  let existingCount = 0;
+  let migratedCount = 0;
+  let skippedCount = 0;
+  if (candidates.length > 0) {
+    const ov = await openVikingCliForMode(dryRun);
+    for (const candidate of candidates) {
+      const action = candidate.destinationExistsWithSameContent ? dryRun ? "Would consolidate duplicate" : "Consolidating duplicate" : dryRun ? "Would migrate" : "Migrating";
+      console.log(`${action} ${candidate.sourceUri} -> ${candidate.destinationUri}`);
+      if (!dryRun) {
+        if (candidate.destinationExistsWithSameContent) {
+          existingCount += 1;
+        } else {
+          await ensureMemoryDirectory(ov, config, parentVikingUri(candidate.destinationUri));
+          await writeMemoryFile(config, ov, candidate.destinationUri, candidate.destinationContent, "create", false);
+        }
+        const removedOriginal = await removeVikingResourceWithRetry(ov, config, candidate.sourceUri);
+        if (!removedOriginal) {
+          console.error(
+            `Migrated copy stored, but original is still processing. Retry later: threadnote forget ${candidate.sourceUri}`
+          );
+          skippedCount += 1;
+        }
+      }
+      migratedCount += 1;
+    }
+  }
+  console.log(
+    [
+      `Project-name migration summary: ${migratedCount} memor${migratedCount === 1 ? "y" : "ies"} ${dryRun ? "would be migrated" : "migrated"} from ${context.oldProject} to ${context.newProject}`,
+      seedManifestUpdated ? `seed manifest ${dryRun ? "would be updated" : "updated"}` : "seed manifest unchanged",
+      `${existingCount} duplicate destination(s) reused`,
+      `${skippedCount} source(s) still processing`,
+      dryRun ? "Run with --apply to perform this migration." : void 0,
+      seedManifestUpdated ? `Run threadnote seed --only ${context.newProject} to re-ingest seeded resources under the new project URI.` : void 0
+    ].filter((part) => part !== void 0).join("; ")
+  );
+}
+async function hasProjectNameMigrationCandidates(config) {
+  const context = await projectNameMigrationContext();
+  return context ? (await projectNameMigrationCandidates(config, context, 1)).length > 0 || await hasSeedManifestProjectNameMigrationCandidate(config, context) : false;
+}
+async function projectNameMigrationContext() {
+  const repoRoot = await gitValue(["rev-parse", "--show-toplevel"]);
+  if (!repoRoot) {
+    return void 0;
+  }
+  const newProject = await resolveRepoName(repoRoot);
+  const oldProject = await resolveRepoFolderName(repoRoot);
+  if (!newProject || !oldProject) {
+    return void 0;
+  }
+  const newSegment = uriSegment(newProject);
+  const oldSegment = uriSegment(oldProject);
+  if (newSegment === oldSegment) {
+    return void 0;
+  }
+  return { newProject, newSegment, oldProject, oldSegment, repoRoot };
+}
+async function projectNameMigrationCandidates(config, context, limit) {
+  const candidates = [];
+  for (const location of projectMemoryLocations()) {
+    const sourceDirectory = (0, import_node_path8.join)(localUserMemoriesRoot(config), ...location.relativePath, context.oldSegment);
+    const sourceDirectoryUri = `viking://user/${uriSegment(config.user)}/memories/${location.uriPath}/${context.oldSegment}`;
+    let entries;
+    try {
+      entries = await (0, import_promises6.readdir)(sourceDirectory, { withFileTypes: true });
+    } catch (_err) {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile() || entry.name.startsWith(".") || !entry.name.endsWith(".md")) {
+        continue;
+      }
+      const sourceUri = `${sourceDirectoryUri}/${entry.name}`;
+      const content = await readTextIfExists((0, import_node_path8.join)(sourceDirectory, entry.name));
+      if (!content) {
+        continue;
+      }
+      const record = parseMemoryDocument(sourceUri, content);
+      if (!record || !canMigrateProjectName(record, context)) {
+        continue;
+      }
+      const metadata = { ...record.metadata, project: context.newProject };
+      const destinationDirectoryUri = memoryDirectoryUri(config, metadata);
+      const destinationDirectory = localMemoryPathForUri(config, destinationDirectoryUri);
+      if (!destinationDirectory) {
+        continue;
+      }
+      const destinationContent = formatMemoryDocument2(record.headerTitle, metadata, record.body);
+      const destination = await projectNameMigrationDestination(
+        destinationDirectory,
+        entry.name,
+        destinationContent,
+        context.oldSegment
+      );
+      candidates.push({
+        destinationContent,
+        destinationExistsWithSameContent: destination.existsWithSameContent,
+        destinationUri: `${destinationDirectoryUri}/${destination.filename}`,
+        sourceUri
+      });
+      if (limit !== void 0 && candidates.length >= limit) {
+        return candidates;
+      }
+    }
+  }
+  return candidates;
+}
+async function hasSeedManifestProjectNameMigrationCandidate(config, context) {
+  return await seedManifestProjectNameMigration(config, context) !== void 0;
+}
+async function migrateSeedManifestProjectName(config, context, dryRun) {
+  const migration = await seedManifestProjectNameMigration(config, context);
+  if (!migration) {
+    return false;
+  }
+  if (dryRun) {
+    console.log(`Would update seed manifest: ${config.manifestPath}`);
+    console.log(migration.output.trimEnd());
+    return true;
+  }
+  await ensureDirectory((0, import_node_path8.dirname)(config.manifestPath), false);
+  const currentContent = await readFileIfExists(config.manifestPath);
+  if (currentContent !== void 0) {
+    const backupPath = `${config.manifestPath}.project-name-${safeTimestamp()}`;
+    await (0, import_promises6.writeFile)(backupPath, currentContent, { encoding: "utf8", mode: 384 });
+    await (0, import_promises6.chmod)(backupPath, 384);
+    console.log(`Backup: ${backupPath}`);
+  }
+  await (0, import_promises6.writeFile)(config.manifestPath, migration.output, { encoding: "utf8", mode: 384 });
+  await (0, import_promises6.chmod)(config.manifestPath, 384);
+  console.log(`Updated seed manifest: ${config.manifestPath}`);
+  return true;
+}
+async function seedManifestProjectNameMigration(config, context) {
+  let manifest;
+  try {
+    manifest = await readSeedManifest(config.manifestPath);
+  } catch (_err) {
+    return void 0;
+  }
+  const oldDefaultUri = `viking://resources/repos/${context.oldSegment}`;
+  const newDefaultUri = `viking://resources/repos/${context.newSegment}`;
+  const newNameExists = manifest.projects.some((project) => uriSegment(project.name) === context.newSegment);
+  let changed = false;
+  let renamedProject = false;
+  const projects = manifest.projects.map((project) => {
+    if (!isSeedManifestProjectNameCandidate(project, context, oldDefaultUri) || newNameExists) {
+      return project;
+    }
+    changed = true;
+    renamedProject = true;
+    return {
+      ...project,
+      name: context.newProject,
+      uri: trimTrailingSlash(project.uri) === oldDefaultUri ? newDefaultUri : project.uri
+    };
+  });
+  const worksets = renamedProject ? manifest.worksets?.map((workset) => {
+    const members = workset.projects.map((projectName) => {
+      if (uriSegment(projectName) !== context.oldSegment) {
+        return projectName;
+      }
+      changed = true;
+      return context.newProject;
+    });
+    return { ...workset, projects: members };
+  }) : manifest.worksets;
+  if (!changed) {
+    return void 0;
+  }
+  return {
+    output: `${index_vite_proxy_tmp_default.dump(
+      {
+        version: manifest.version,
+        projects: projects.map((project) => ({
+          name: project.name,
+          path: project.path,
+          uri: project.uri,
+          seed: [...project.seed]
+        })),
+        ...worksets ? {
+          worksets: worksets.map((workset) => ({
+            name: workset.name,
+            ...workset.description ? { description: workset.description } : {},
+            projects: [...workset.projects]
+          }))
+        } : {},
+        ...manifest.futureMonorepo ? {
+          future_monorepo: {
+            path_candidates: [...manifest.futureMonorepo.pathCandidates],
+            uri: manifest.futureMonorepo.uri
+          }
+        } : {}
+      },
+      { lineWidth: 120, noRefs: true }
+    )}`
+  };
+}
+function isSeedManifestProjectNameCandidate(project, context, oldDefaultUri) {
+  if (uriSegment(project.name) !== context.oldSegment) {
+    return false;
+  }
+  return trimTrailingSlash(project.uri) === oldDefaultUri || expandPath(project.path) === context.repoRoot;
+}
+function canMigrateProjectName(record, context) {
+  const projectSegment = record.metadata.project ? uriSegment(record.metadata.project) : context.oldSegment;
+  return projectSegment === context.oldSegment || projectSegment === context.newSegment;
+}
+async function projectNameMigrationDestination(destinationDirectory, filename, content, oldProjectSegment) {
+  const direct = await projectNameMigrationDestinationState(destinationDirectory, filename, content);
+  if (!direct.exists || direct.sameContent) {
+    return { existsWithSameContent: direct.sameContent, filename };
+  }
+  const stem = filename.replace(/\.md$/i, "");
+  const fromOldProject = `${stem}-from-${oldProjectSegment}.md`;
+  const renamed = await projectNameMigrationDestinationState(destinationDirectory, fromOldProject, content);
+  if (!renamed.exists || renamed.sameContent) {
+    return { existsWithSameContent: renamed.sameContent, filename: fromOldProject };
+  }
+  return {
+    existsWithSameContent: false,
+    filename: `${stem}-from-${oldProjectSegment}-${sha256(content).slice(0, 12)}.md`
+  };
+}
+async function projectNameMigrationDestinationState(destinationDirectory, filename, content) {
+  const existing = await readTextIfExists((0, import_node_path8.join)(destinationDirectory, filename));
+  return { exists: existing !== void 0, sameContent: existing?.trim() === content.trim() };
+}
+function projectMemoryLocations() {
+  return [
+    { relativePath: ["durable", "projects"], uriPath: "durable/projects" },
+    { relativePath: ["durable", "archived"], uriPath: "durable/archived" },
+    { relativePath: ["durable", "superseded"], uriPath: "durable/superseded" },
+    { relativePath: ["handoffs", "active"], uriPath: "handoffs/active" },
+    { relativePath: ["handoffs", "archived"], uriPath: "handoffs/archived" },
+    { relativePath: ["handoffs", "superseded"], uriPath: "handoffs/superseded" },
+    { relativePath: ["incidents", "active"], uriPath: "incidents/active" },
+    { relativePath: ["incidents", "archived"], uriPath: "incidents/archived" },
+    { relativePath: ["incidents", "superseded"], uriPath: "incidents/superseded" }
+  ];
+}
 async function runRecall(config, options) {
   if (options.dryRun !== true) {
     await syncSharedReposAndLog(config);
@@ -11456,6 +11910,9 @@ async function runRecall(config, options) {
   const dryRun = options.dryRun === true;
   const inferredUri = options.uri ?? (options.inferScope === false ? void 0 : await inferRecallUri(config, projectQuery));
   const project = await inferProjectFromQuery(config.manifestPath, options.project ?? projectQuery);
+  const projectMemoryName = await recallProjectMemoryName(options.project, {
+    includeProcessCwd: true
+  });
   const nodeLimit = options.nodeLimit ? parsePositiveInteger(options.nodeLimit, "node limit") : void 0;
   const explicitWorkset = options.workset ? await requireWorkset(config.manifestPath, options.workset) : void 0;
   const searchArgs = (scopeUri) => [
@@ -11475,9 +11932,19 @@ async function runRecall(config, options) {
   const passes = [
     await recallSearchHits(config, ov, searchArgs(inferredUri), { dryRun, includeArchived })
   ];
+  const scopedRecallUris = new Set([inferredUri].filter((uri) => uri !== void 0));
   if (options.project && project) {
     const projectMemoryUri = `viking://user/${uriSegment(config.user)}/memories/durable/projects/${uriSegment(project.name)}`;
-    passes.push(await recallSearchHits(config, ov, searchArgs(projectMemoryUri), { dryRun, includeArchived }));
+    if (!scopedRecallUris.has(projectMemoryUri)) {
+      scopedRecallUris.add(projectMemoryUri);
+      passes.push(await recallSearchHits(config, ov, searchArgs(projectMemoryUri), { dryRun, includeArchived }));
+    }
+  }
+  for (const scope of projectMemoryScopeUris(config, projectMemoryName, includeArchived)) {
+    if (!scopedRecallUris.has(scope)) {
+      scopedRecallUris.add(scope);
+      passes.push(await recallSearchHits(config, ov, searchArgs(scope), { dryRun, includeArchived }));
+    }
   }
   const seededUri = project ? trimTrailingSlash(project.uri) : void 0;
   if (seededUri?.startsWith("viking://") && seededUri !== inferredUri && !options.uri && options.inferScope !== false) {
@@ -11486,7 +11953,9 @@ async function runRecall(config, options) {
   const workset = !options.uri && explicitWorkset ? explicitWorkset : !options.uri && options.inferScope !== false ? await inferWorksetFromQuery(config.manifestPath, projectQuery) : void 0;
   if (workset && workset.projects.length > 0) {
     console.log(`Workset scope: ${workset.name} (${workset.projects.map((member) => member.name).join(", ")})`);
-    const alreadyScoped = new Set([inferredUri, seededUri].filter((uri) => uri !== void 0));
+    const alreadyScoped = new Set(
+      [inferredUri, seededUri, ...scopedRecallUris].filter((uri) => uri !== void 0)
+    );
     const worksetScopes = worksetScopeUris(config, workset).filter((uri) => !alreadyScoped.has(uri)).slice(0, MAX_WORKSET_PASSES);
     for (const scope of worksetScopes) {
       passes.push(await recallSearchHits(config, ov, searchArgs(scope), { dryRun, includeArchived }));
@@ -12059,8 +12528,8 @@ async function removeVikingResourceWithRetry(ov, config, uri) {
   return false;
 }
 async function vikingResourceExists2(ov, config, uri) {
-  const stat6 = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
-  return stat6.exitCode === 0;
+  const stat5 = await runCommand(ov, withIdentity(config, ["stat", uri]), { allowFailure: true });
+  return stat5.exitCode === 0;
 }
 async function ensureDurableMemoryDirectory(ov, config) {
   await ensureMemoryDirectory(ov, config, durableMemoryDirectoryUri(config));
@@ -12139,6 +12608,27 @@ function worksetScopeUris(config, workset) {
   }
   return [...new Set(scopes)];
 }
+async function recallProjectMemoryName(explicitProject, options) {
+  return normalizeOptionalMetadata2(explicitProject) ?? await resolveWorkspaceRepoName(options);
+}
+function projectMemoryScopeUris(config, projectName, includeArchived) {
+  if (!projectName) {
+    return [];
+  }
+  const base = `viking://user/${uriSegment(config.user)}/memories`;
+  const projectSegment = uriSegment(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 exactMemoryScopes(config, includeArchived, query, project) {
   return exactMemoryScopeUris({
     agentMemoriesUri: `viking://agent/${uriSegment(config.agentId)}/memories`,
@@ -13375,7 +13865,7 @@ async function runInitManifest(config, options) {
       continue;
     }
     seen.add(identity);
-    projects.push(projectManifestForRepo(repoRoot, projects));
+    projects.push(await projectManifestForRepo(repoRoot, projects));
   }
   const outputManifest = {
     version: 1,
@@ -13483,8 +13973,8 @@ async function projectIdentity(path2) {
     return expanded;
   }
 }
-function projectManifestForRepo(repoRoot, existingProjects) {
-  const baseName = uriSegment((0, import_node_path13.basename)(repoRoot));
+async function projectManifestForRepo(repoRoot, existingProjects) {
+  const baseName = uriSegment(await resolveRepoName(repoRoot) ?? (0, import_node_path13.basename)(repoRoot));
   const usedNames = new Set(existingProjects.map((project) => project.name));
   const usedUris = new Set(existingProjects.map((project) => project.uri));
   let name = baseName;
@@ -13686,23 +14176,6 @@ function redactJsonValue(value) {
 function isSensitiveKey(key) {
   return /token|secret|password|credential|authorization|api[_-]?key|client[_-]?secret|bearer/i.test(key);
 }
-function detectSecretMatches(content) {
-  const detectors = [
-    { label: "private-key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
-    { label: "openai-key", regex: /sk-[A-Za-z0-9_-]{24,}/ },
-    { label: "github-token", regex: /gh[pousr]_[A-Za-z0-9_]{24,}/ },
-    { label: "slack-token", regex: /xox[abprs]-[A-Za-z0-9-]{24,}/ },
-    { label: "bearer-token", regex: /Bearer\s+[A-Za-z0-9._~+/=-]{24,}/i },
-    { label: "aws-access-key", regex: /AKIA[0-9A-Z]{16}/ }
-  ];
-  const matches = [];
-  for (const detector of detectors) {
-    if (detector.regex.test(content)) {
-      matches.push(detector.label);
-    }
-  }
-  return matches;
-}
 
 // src/lifecycle.ts
 var import_node_child_process4 = require("node:child_process");
@@ -13821,6 +14294,7 @@ function escapeRegExp3(value) {
 // src/update.ts
 var NPM_PACKAGE_NAME = "threadnote";
 var DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org/";
+var ALLOW_UNTRUSTED_REGISTRY_ENV = "THREADNOTE_ALLOW_UNTRUSTED_NPM_REGISTRY";
 var UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1e3;
 var POST_UPDATE_MIGRATIONS_FILE = "post-update-migrations.json";
 var POST_UPDATE_STATE_FILE = "post-update-state.json";
@@ -13851,7 +14325,7 @@ async function maybeNotifyUpdate(config, options = {}) {
   }
 }
 async function runUpdate(config, options) {
-  const registry = normalizeRegistry(options.registry ?? updateRegistry());
+  const registry = resolveUpdateRegistry(options.registry, options.allowUntrustedRegistry);
   const info2 = await withSpinner(
     "Checking npm for latest threadnote version",
     () => getUpdateInfo(config, {
@@ -14213,6 +14687,9 @@ async function applicablePostUpdateMigrations(config, options) {
     if (migration.requiresLegacyHandoffs === true && !await hasLegacyLifecycleHandoffCandidates(config)) {
       continue;
     }
+    if (migration.requiresProjectNameConsolidation === true && !await hasProjectNameMigrationCandidates(config)) {
+      continue;
+    }
     applicable.push(migration);
   }
   return applicable;
@@ -14239,6 +14716,7 @@ function parsePostUpdateMigration(value) {
     instructions: stringArray(value, "instructions"),
     introducedIn: value.introducedIn,
     requiresLegacyHandoffs: value.requiresLegacyHandoffs === true,
+    requiresProjectNameConsolidation: value.requiresProjectNameConsolidation === true,
     title: value.title
   };
 }
@@ -14362,10 +14840,31 @@ function updatePackageCommand(runtime, registry) {
   };
 }
 function normalizeRegistry(registry) {
-  return registry.endsWith("/") ? registry : `${registry}/`;
+  const normalized = registry.endsWith("/") ? registry : `${registry}/`;
+  const url = new URL(normalized);
+  if (url.protocol !== "https:") {
+    throw new Error(`npm registry must use https: ${normalized}`);
+  }
+  return url.toString();
 }
 function updateRegistry() {
-  return normalizeRegistry(process.env.THREADNOTE_NPM_REGISTRY ?? DEFAULT_NPM_REGISTRY);
+  return resolveUpdateRegistry(void 0, false);
+}
+function resolveUpdateRegistry(registry, allowUntrustedRegistry) {
+  const normalized = normalizeRegistry(registry ?? process.env.THREADNOTE_NPM_REGISTRY ?? DEFAULT_NPM_REGISTRY);
+  if (normalized !== DEFAULT_NPM_REGISTRY && !allowsUntrustedRegistry(allowUntrustedRegistry)) {
+    throw new Error(
+      `Refusing custom npm registry ${normalized}: threadnote update does not verify package signatures from alternate registries. Use the default registry, pass --allow-untrusted-registry, or set ${ALLOW_UNTRUSTED_REGISTRY_ENV}=1 only for an approved mirror.`
+    );
+  }
+  return normalized;
+}
+function allowsUntrustedRegistry(option) {
+  if (option === true) {
+    return true;
+  }
+  const envValue = process.env[ALLOW_UNTRUSTED_REGISTRY_ENV]?.trim().toLowerCase();
+  return envValue === "1" || envValue === "true" || envValue === "yes";
 }
 function isUpdateNotificationDisabled() {
   return process.env.CI !== void 0 || process.env.NO_UPDATE_NOTIFIER !== void 0 || process.env.THREADNOTE_NO_UPDATE_CHECK !== void 0;
@@ -14567,7 +15066,7 @@ async function repairManifest(config, dryRun) {
     console.log(`WARN cannot create replacement manifest from current directory: ${errorMessage(err)}`);
     return;
   }
-  const project = projectManifestForRepo(repoRoot, []);
+  const project = await projectManifestForRepo(repoRoot, []);
   const output2 = index_vite_proxy_tmp_default.dump(
     {
       version: 1,
@@ -15875,7 +16374,7 @@ function parsePackageManager(value) {
 // src/version_command.ts
 async function runVersion(config, options) {
   const currentVersion = await currentPackageVersion();
-  const registry = normalizeRegistry(options.registry ?? updateRegistry());
+  const registry = resolveUpdateRegistry(options.registry, options.allowUntrustedRegistry);
   let latestVersion;
   let latestWarning;
   try {
@@ -15988,7 +16487,11 @@ async function readManagedMemory(config, uri) {
   if (!path2) {
     throw new Error(`Manager can only read current-user memory URIs: ${uri}`);
   }
-  const [content, pathStat] = await Promise.all([(0, import_promises16.readFile)(path2, "utf8"), (0, import_promises16.stat)(path2)]);
+  const pathStat = await (0, import_promises16.lstat)(path2);
+  if (!pathStat.isFile()) {
+    throw new Error(`Manager can only read regular memory files: ${uri}`);
+  }
+  const content = await (0, import_promises16.readFile)(path2, "utf8");
   const relativePath = (0, import_node_path16.relative)(localMemoriesRoot(config), path2).split(import_node_path16.sep).join("/");
   const record = parseMemoryDocument(uri, content);
   return {
@@ -16296,10 +16799,13 @@ async function serveStatic(context, url, response) {
   response.end(content);
 }
 async function readTree(config, path2, uri, relativePath, options = {}) {
-  const pathStat = await (0, import_promises16.stat)(path2);
+  const pathStat = await (0, import_promises16.lstat)(path2);
   const name = relativePath ? relativePath.split("/").at(-1) ?? relativePath : options.rootName ?? "memories";
   const isDir = pathStat.isDirectory();
   if (!isDir) {
+    if (!pathStat.isFile()) {
+      throw new Error(`Manager can only read regular files or directories: ${uri}`);
+    }
     const record = options.parseMemoryDocuments === false ? void 0 : parseMemoryDocument(uri, await (0, import_promises16.readFile)(path2, "utf8").catch(() => ""));
     return {
       isDir: false,
@@ -16316,7 +16822,7 @@ async function readTree(config, path2, uri, relativePath, options = {}) {
   }
   const entries = await (0, import_promises16.readdir)(path2, { withFileTypes: true });
   const children = await Promise.all(
-    entries.sort(
+    entries.filter((entry) => entry.isDirectory() || entry.isFile()).sort(
       (left, right) => Number(right.isDirectory()) - Number(left.isDirectory()) || left.name.localeCompare(right.name)
     ).map((entry) => {
       const childRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
@@ -16494,7 +17000,7 @@ async function removeManagedFolder(config, uri) {
   if (!path2) {
     throw new Error(`Manager can only remove current-user memory folders: ${uri}`);
   }
-  const pathStat = await (0, import_promises16.stat)(path2);
+  const pathStat = await (0, import_promises16.lstat)(path2);
   if (!pathStat.isDirectory()) {
     throw new Error(`Not a folder: ${uri}`);
   }
@@ -16956,10 +17462,10 @@ async function main() {
     }
     await maybeNotifyUpdate(config, { dryRun: options.dryRun === true });
   });
-  program2.command("version").description("Print the installed Threadnote version, latest npm version, and release notes").option("--registry <url>", "npm registry URL", process.env.THREADNOTE_NPM_REGISTRY).action(async (options) => {
+  program2.command("version").description("Print the installed Threadnote version, latest npm version, and release notes").option("--registry <url>", "npm registry URL").option("--allow-untrusted-registry", "Allow a non-default npm registry without package signature verification").action(async (options) => {
     await runVersion(getRuntimeConfig(program2), options);
   });
-  program2.command("update").description("Update the published Threadnote package, then repair local shims and MCP config").option("--check", "Only check whether a newer version is available").option("--dry-run", "Print update and repair commands without running them").option("--force", "Run package-manager update even if this version is already current").option("--registry <url>", "npm registry URL", process.env.THREADNOTE_NPM_REGISTRY).option("--runtime <runtime>", "auto, npm, bun, or deno", parseUpdateRuntime, "auto").option("--no-repair", "Skip threadnote repair after updating the package").option("--no-post-update", "Skip post-update migration prompts").option("--yes", "Accept applicable post-update migrations without prompting").action(async (options) => {
+  program2.command("update").description("Update the published Threadnote package, then repair local shims and MCP config").option("--check", "Only check whether a newer version is available").option("--dry-run", "Print update and repair commands without running them").option("--force", "Run package-manager update even if this version is already current").option("--registry <url>", "npm registry URL").option("--allow-untrusted-registry", "Allow a non-default npm registry without package signature verification").option("--runtime <runtime>", "auto, npm, bun, or deno", parseUpdateRuntime, "auto").option("--no-repair", "Skip threadnote repair after updating the package").option("--no-post-update", "Skip post-update migration prompts").option("--yes", "Accept applicable post-update migrations without prompting").action(async (options) => {
     await runUpdate(getRuntimeConfig(program2), options);
   });
   program2.command("post-update", { hidden: true }).description("Run packaged post-update migration prompts").requiredOption("--from-version <version>", "Version before update").requiredOption("--to-version <version>", "Version after update").option("--dry-run", "Print post-update actions without running them").option("--yes", "Accept applicable post-update migrations without prompting").action(async (options) => {
@@ -17038,6 +17544,9 @@ async function main() {
   program2.command("migrate-lifecycle").description("Move clear legacy handoff memories into lifecycle-aware archive paths").option("--apply", "Perform the migration; without this, prints a dry run").option("--dry-run", "Print migration actions without writing or removing memories").option("--limit <count>", "Maximum number of legacy handoffs to migrate").action(async (options) => {
     await runMigrateLifecycle(getRuntimeConfig(program2), options);
   });
+  program2.command("migrate-project-names").description("Move memories from old clone-folder project names to the git remote repo name").option("--apply", "Perform the migration; without this, prints a dry run").option("--dry-run", "Print migration actions without writing or removing memories").option("--limit <count>", "Maximum number of memories to migrate").action(async (options) => {
+    await runMigrateProjectNames(getRuntimeConfig(program2), options);
+  });
   program2.command("recall").description("Search shared OpenViking context").requiredOption("--query <query>", "Search query").option("--dry-run", "Print ov command without searching").option("--include-archived", "Include archived memories in recall results").option("-n, --node-limit <count>", "Maximum number of search results").option("--no-infer-scope", "Disable query-based scope inference").option("--project <name>", "Prioritize a project: add a scoped pass over its memories alongside the global search").option("--threshold <score>", "Minimum relevance score 0-1 (default 0.45); lower to broaden when recall is empty").option("--uri <uri>", "Restrict search to a viking:// URI").option(
     "--workset <name>",
     "Recall across a named seed-manifest workset (a set of related repos) as one working set"