threadnote 1.6.2 → 1.7.0

package/config/post-update-migrations.json

@@ -18,6 +18,26 @@
         "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 folders for the old folder-derived project name from the current workspace.",
+        "It also renames the matching seed manifest project 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 unrelated project folders are left untouched."
+      ],
+      "commandArgs": ["migrate-project-names", "--apply"],
+      "instructions": [
+        "Post-update project-name migration finished. Future default handoffs and memories for this repo 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,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);
@@ -11581,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) => [
@@ -11600,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) {
@@ -11611,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 }));
@@ -12264,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`,
@@ -13500,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,
@@ -13608,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;
@@ -14322,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;
@@ -14348,6 +14716,7 @@ function parsePostUpdateMigration(value) {
     instructions: stringArray(value, "instructions"),
     introducedIn: value.introducedIn,
     requiresLegacyHandoffs: value.requiresLegacyHandoffs === true,
+    requiresProjectNameConsolidation: value.requiresProjectNameConsolidation === true,
     title: value.title
   };
 }
@@ -14697,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,
@@ -17175,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"

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.0",
   "type": "commonjs",
   "main": "dist/threadnote.cjs",
   "description": "Shared local context and handoffs for development agents",