threadnote 1.6.2 → 1.7.1

package/config/post-update-migrations.json

@@ -18,6 +18,27 @@
         "If Threadnote reported any original files were still being processed, rerun the printed threadnote forget <uri> command later."
       ],
       "requiresLegacyHandoffs": true
+    },
+    {
+      "id": "remote-project-name-consolidation-v1",
+      "introducedIn": "1.6.3",
+      "title": "Consolidate memories under the git remote project name",
+      "description": [
+        "Threadnote now uses the git remote repository name as the default project identifier instead of the clone folder name.",
+        "This migration scans personal lifecycle-aware memory project folders and uses repo_path evidence in memories, plus matching seed manifest paths when present, to resolve git remote names.",
+        "It covers every detected personal memory project, not just the workspace where threadnote update was run.",
+        "It also renames matching seed manifest projects and workset references so future seeded guidance uses the remote-derived project name.",
+        "Matching memories are copied under the remote-derived project name with updated project metadata, then the old copy is removed.",
+        "If a destination file already exists with different content, Threadnote keeps both by writing the migrated copy with a -from-<old-project> suffix.",
+        "Shared team memories and projects without repo path evidence are left untouched."
+      ],
+      "commandArgs": ["migrate-project-names", "--apply"],
+      "instructions": [
+        "Post-update project-name migration finished. Future default handoffs and memories for migrated repos will use the git remote repository name as their project.",
+        "If the migration updated your seed manifest, run threadnote seed --only <new-project-name> to re-ingest seeded resources under the new project URI.",
+        "If Threadnote reported any original files were still being processed, rerun the printed threadnote forget <uri> command later."
+      ],
+      "requiresProjectNameConsolidation": true
     }
   ]
 }

package/dist/mcp_server.cjs

@@ -35592,6 +35592,23 @@ function parseJsonConfigObject(content) {
 function redactText(content) {
   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, "\\$&");
 }
@@ -35711,6 +35728,7 @@ async function runCommand(executable, args, options = {}) {
       {
         cwd: options.cwd,
         encoding: "utf8",
+        env: commandEnvironment(executable, options.env),
         maxBuffer: maxOutputBytes
       },
       (err, stdout2, stderr) => {
@@ -35750,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 };
@@ -35786,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);
@@ -35926,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;
@@ -35944,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) }
   ]);
 }
@@ -40375,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;
@@ -40386,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(
@@ -40400,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(
@@ -41087,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,

package/dist/threadnote.cjs

@@ -3676,6 +3676,23 @@ function parseJsonConfigObject(content) {
 function redactText(content) {
   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 = [];
   async function visit(path2) {
@@ -3863,6 +3880,7 @@ async function runCommand(executable, args, options = {}) {
       {
         cwd: options.cwd,
         encoding: "utf8",
+        env: commandEnvironment(executable, options.env),
         maxBuffer: maxOutputBytes
       },
       (err, stdout2, stderr) => {
@@ -3902,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 };
@@ -3939,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;
@@ -3954,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" });
@@ -4223,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;
@@ -4241,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) }
   ]);
 }
@@ -5251,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;
@@ -7617,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";
@@ -11558,6 +11630,453 @@ 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 contexts = await projectNameMigrationContexts(config);
+  if (contexts.length === 0) {
+    console.log("No git remote project-name changes apply across configured projects.");
+    return;
+  }
+  const plans = [];
+  let remaining = limit;
+  for (const context of contexts) {
+    const candidates2 = remaining === 0 ? [] : await projectNameMigrationCandidates(config, context, remaining);
+    plans.push({ candidates: candidates2, context });
+    if (remaining !== void 0) {
+      remaining = Math.max(0, remaining - candidates2.length);
+    }
+  }
+  const seedManifestMigration = await seedManifestProjectNameMigration(config, contexts);
+  if (!plans.some((plan) => plan.candidates.length > 0) && !seedManifestMigration) {
+    console.log("No project-name migration candidates found across configured projects.");
+    return;
+  }
+  const seedManifestUpdated = await migrateSeedManifestProjectNames(config, seedManifestMigration, dryRun);
+  let existingCount = 0;
+  let migratedCount = 0;
+  let skippedCount = 0;
+  const candidates = plans.flatMap((plan) => [...plan.candidates]);
+  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;
+    }
+  }
+  const activeContexts = projectNameMigrationActiveContexts(plans, seedManifestMigration);
+  const newProjectsToSeed = [...new Set(seedManifestMigration?.newProjects ?? [])];
+  console.log(
+    [
+      projectNameMigrationSummary(migratedCount, dryRun, activeContexts),
+      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,
+      ...newProjectsToSeed.map(
+        (project) => `Run threadnote seed --only ${project} to re-ingest seeded resources under the new project URI.`
+      )
+    ].filter((part) => part !== void 0).join("; ")
+  );
+}
+async function hasProjectNameMigrationCandidates(config) {
+  const contexts = await projectNameMigrationContexts(config);
+  if (contexts.length === 0) {
+    return false;
+  }
+  for (const context of contexts) {
+    if ((await projectNameMigrationCandidates(config, context, 1)).length > 0) {
+      return true;
+    }
+  }
+  return await seedManifestProjectNameMigration(config, contexts) !== void 0;
+}
+async function projectNameMigrationContexts(config) {
+  const evidence = await projectNameMigrationMemoryEvidence(config);
+  const contexts = [];
+  let manifest;
+  try {
+    manifest = await readSeedManifest(config.manifestPath);
+  } catch (_err) {
+    manifest = void 0;
+  }
+  if (manifest) {
+    for (const project of manifest.projects) {
+      const projectEvidence = evidence.get(uriSegment(project.name));
+      if (projectEvidence) {
+        projectEvidence.repoPaths.add(expandPath(project.path));
+      }
+    }
+  }
+  for (const projectEvidence of evidence.values()) {
+    for (const repoPath of projectEvidence.repoPaths) {
+      const context = await projectNameMigrationContextForRepoPath(projectEvidence.oldProject, repoPath);
+      if (context) {
+        contexts.push(context);
+      }
+    }
+  }
+  const currentContext = await currentWorkspaceProjectNameMigrationContext(evidence);
+  if (currentContext) {
+    contexts.push(currentContext);
+  }
+  return dedupeProjectNameMigrationContexts(contexts);
+}
+async function projectNameMigrationMemoryEvidence(config) {
+  const evidence = /* @__PURE__ */ new Map();
+  for (const location of projectMemoryLocations()) {
+    const locationRoot = (0, import_node_path8.join)(localUserMemoriesRoot(config), ...location.relativePath);
+    let projectEntries;
+    try {
+      projectEntries = await (0, import_promises6.readdir)(locationRoot, { withFileTypes: true });
+    } catch (_err) {
+      continue;
+    }
+    for (const projectEntry of projectEntries) {
+      if (!projectEntry.isDirectory() || projectEntry.name.startsWith(".")) {
+        continue;
+      }
+      const oldSegment = projectEntry.name;
+      const projectEvidence = ensureProjectNameMigrationEvidence(evidence, oldSegment);
+      const projectDirectory = (0, import_node_path8.join)(locationRoot, projectEntry.name);
+      let memoryEntries;
+      try {
+        memoryEntries = await (0, import_promises6.readdir)(projectDirectory, { withFileTypes: true });
+      } catch (_err) {
+        continue;
+      }
+      for (const memoryEntry of memoryEntries) {
+        if (!memoryEntry.isFile() || memoryEntry.name.startsWith(".") || !memoryEntry.name.endsWith(".md")) {
+          continue;
+        }
+        const content = await readTextIfExists((0, import_node_path8.join)(projectDirectory, memoryEntry.name));
+        if (!content) {
+          continue;
+        }
+        const sourceUri = `viking://user/${uriSegment(config.user)}/memories/${location.uriPath}/${oldSegment}/${memoryEntry.name}`;
+        const record = parseMemoryDocument(sourceUri, content);
+        if (record?.metadata.project && uriSegment(record.metadata.project) === oldSegment) {
+          projectEvidence.oldProject = record.metadata.project;
+        }
+        const repoPath = repoPathEvidenceFromMemory(content);
+        if (repoPath) {
+          projectEvidence.repoPaths.add(repoPath);
+        }
+      }
+    }
+  }
+  return evidence;
+}
+function ensureProjectNameMigrationEvidence(evidence, oldSegment) {
+  const existing = evidence.get(oldSegment);
+  if (existing) {
+    return existing;
+  }
+  const created = { oldProject: oldSegment, oldSegment, repoPaths: /* @__PURE__ */ new Set() };
+  evidence.set(oldSegment, created);
+  return created;
+}
+function repoPathEvidenceFromMemory(content) {
+  const match = /^repo_path:\s*(.+)$/m.exec(content);
+  if (!match?.[1]) {
+    return void 0;
+  }
+  const cleaned = match[1].trim().replace(/^['"`]+|['"`]+$/g, "").replace(/[.,;]+$/g, "");
+  if (!cleaned.startsWith("/") && !cleaned.startsWith("~/")) {
+    return void 0;
+  }
+  return expandPath(cleaned);
+}
+async function projectNameMigrationContextForRepoPath(oldProject, repoPath) {
+  const repoRoot = await gitValue(["rev-parse", "--show-toplevel"], repoPath);
+  if (!repoRoot) {
+    return void 0;
+  }
+  const newProject = await resolveGitRemoteRepoName(repoRoot);
+  if (!newProject) {
+    return void 0;
+  }
+  return projectNameMigrationContextFromParts({
+    newProject,
+    oldProject,
+    repoRoot
+  });
+}
+async function currentWorkspaceProjectNameMigrationContext(evidence) {
+  const repoRoot = await gitValue(["rev-parse", "--show-toplevel"]);
+  if (!repoRoot) {
+    return void 0;
+  }
+  const newProject = await resolveGitRemoteRepoName(repoRoot);
+  const oldProject = await resolveRepoFolderName(repoRoot);
+  if (!newProject || !oldProject) {
+    return void 0;
+  }
+  const oldSegment = uriSegment(oldProject);
+  if (!evidence.has(oldSegment)) {
+    return void 0;
+  }
+  return projectNameMigrationContextFromParts({ newProject, oldProject, repoRoot });
+}
+function projectNameMigrationContextFromParts(params) {
+  const newSegment = uriSegment(params.newProject);
+  const oldSegment = uriSegment(params.oldProject);
+  if (newSegment === oldSegment) {
+    return void 0;
+  }
+  return {
+    newProject: params.newProject,
+    newSegment,
+    oldProject: params.oldProject,
+    oldSegment,
+    repoRoot: params.repoRoot
+  };
+}
+function dedupeProjectNameMigrationContexts(contexts) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const context of contexts) {
+    const key = `${context.oldSegment}\0${context.newSegment}\0${context.repoRoot}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    out.push(context);
+  }
+  return out;
+}
+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;
+}
+function projectNameMigrationActiveContexts(plans, seedManifestMigration) {
+  return dedupeProjectNameMigrationContexts([
+    ...plans.filter((plan) => plan.candidates.length > 0).map((plan) => plan.context),
+    ...seedManifestMigration?.contexts ?? []
+  ]);
+}
+function projectNameMigrationSummary(migratedCount, dryRun, contexts) {
+  const memoryWord = migratedCount === 1 ? "memory" : "memories";
+  const verb = dryRun ? "would be migrated" : "migrated";
+  if (contexts.length === 1) {
+    const [context] = contexts;
+    return `Project-name migration summary: ${migratedCount} ${memoryWord} ${verb} from ${context.oldProject} to ${context.newProject}`;
+  }
+  const renameSummary = contexts.map((context) => `${context.oldProject} -> ${context.newProject}`).join(", ");
+  return `Project-name migration summary: ${migratedCount} ${memoryWord} ${verb} across ${contexts.length} project rename(s)${renameSummary ? `: ${renameSummary}` : ""}`;
+}
+async function migrateSeedManifestProjectNames(config, migration, dryRun) {
+  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, contexts) {
+  let manifest;
+  try {
+    manifest = await readSeedManifest(config.manifestPath);
+  } catch (_err) {
+    return void 0;
+  }
+  const renamed = /* @__PURE__ */ new Map();
+  let changed = false;
+  const projects = manifest.projects.map((project) => {
+    const context = contexts.find(
+      (candidate) => isSeedManifestProjectNameCandidate(
+        project,
+        candidate,
+        `viking://resources/repos/${candidate.oldSegment}`,
+        `viking://resources/repos/${candidate.newSegment}`
+      )
+    );
+    if (!context) {
+      return project;
+    }
+    const newNameExists = manifest.projects.some(
+      (other) => other !== project && uriSegment(other.name) === context.newSegment
+    );
+    if (newNameExists || [...renamed.values()].some((existing) => existing.newSegment === context.newSegment)) {
+      return project;
+    }
+    changed = true;
+    renamed.set(context.oldSegment, context);
+    return {
+      ...project,
+      name: context.newProject,
+      uri: trimTrailingSlash(project.uri) === `viking://resources/repos/${context.oldSegment}` ? `viking://resources/repos/${context.newSegment}` : project.uri
+    };
+  });
+  const worksets = renamed.size > 0 ? manifest.worksets?.map((workset) => {
+    const members = workset.projects.map((projectName) => {
+      const context = renamed.get(uriSegment(projectName));
+      if (!context) {
+        return projectName;
+      }
+      changed = true;
+      return context.newProject;
+    });
+    return { ...workset, projects: members };
+  }) : manifest.worksets;
+  if (!changed) {
+    return void 0;
+  }
+  return {
+    contexts: [...renamed.values()],
+    newProjects: [...new Set([...renamed.values()].map((context) => context.newProject))],
+    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, newDefaultUri) {
+  const nameSegment = uriSegment(project.name);
+  const uriMatchesOld = trimTrailingSlash(project.uri) === oldDefaultUri;
+  const pathMatchesRepo = expandPath(project.path) === context.repoRoot;
+  if (nameSegment === context.newSegment && !uriMatchesOld) {
+    return false;
+  }
+  if (nameSegment !== context.oldSegment && !uriMatchesOld && !pathMatchesRepo) {
+    return false;
+  }
+  return nameSegment !== context.newSegment || uriMatchesOld || trimTrailingSlash(project.uri) !== newDefaultUri;
+}
+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);
@@ -11581,6 +12100,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) => [
@@ -11600,9 +12122,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) {
@@ -11611,7 +12143,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 }));
@@ -12264,6 +12798,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`,
@@ -13500,7 +14055,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,
@@ -13608,8 +14163,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;
@@ -14322,6 +14877,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;
@@ -14348,6 +14906,7 @@ function parsePostUpdateMigration(value) {
     instructions: stringArray(value, "instructions"),
     introducedIn: value.introducedIn,
     requiresLegacyHandoffs: value.requiresLegacyHandoffs === true,
+    requiresProjectNameConsolidation: value.requiresProjectNameConsolidation === true,
     title: value.title
   };
 }
@@ -14697,7 +15256,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,
@@ -17175,6 +17734,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"

package/docs/index.html

@@ -1006,7 +1006,7 @@
 
               <!-- threadnote MCP -->
               <g font-family="JetBrains Mono, monospace" font-size="13" fill="#ececf1">
-                <rect x="340" y="150" width="200" height="60" rx="10" fill="#5ee0c5" />
+                <rect x="300" y="150" width="280" height="60" rx="10" fill="#5ee0c5" />
                 <text x="440" y="178" text-anchor="middle" fill="#0a0a0d" font-weight="600">threadnote-mcp-server</text>
                 <text x="440" y="196" text-anchor="middle" fill="#0a0a0d" opacity="0.7" font-size="11">
                   recall · read · list · remember · share

package/package.json

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