@yandy0725/pi-memory 1.3.3 → 1.4.0

package/README.md

@@ -1,6 +1,6 @@
 # pi-memory
 
-File-system driven persistent memory layer for pi coding agent. Stores project knowledge across sessions — facts, preferences, debugging history — in plain Markdown files under `~/.pi/memory/<project-hash>/`.
+File-system driven persistent memory layer for pi coding agent. Stores project knowledge across sessions — facts, preferences, debugging history — in plain Markdown files under `~/.pi/memory/<git|local>/<project>/`.
 
 Aligned with Claude Code's auto memory mechanism: per-topic MEMORY.md index, automatic topic file surfacing based on relevance, per-turn memory extraction, and typed memory categories.
 
@@ -17,7 +17,7 @@ Aligned with Claude Code's auto memory mechanism: per-topic MEMORY.md index, aut
 - **Dream nudge**: after N sessions or N hours, a gentle notification suggests running `/dream`
 - **`/memory` command**: show status, toggle on/off, inspect index and topic files
 - **Session search**: the `memory search scope=sessions` action queries past conversation history
-- **Branch-safe**: memory directory is keyed by the git root (or absolute path), so forks share memory naturally
+- **Readable, clone-safe layout**: memory lives under `~/.pi/memory/git/<host__owner__repo>/` for git repos with an http(s)/ssh/git remote (including scp-style and `git+ssh`/`git+https`), and `~/.pi/memory/local/<absolute-path>/` otherwise — clones and worktrees of the same repo share memory (a fork has its own remote, so it gets its own directory)
 - **Path traversal protection**: topic files are validated against escaping the memory directory
 
 ## Install
@@ -86,13 +86,13 @@ Create `memory.json` in the agent directory (`~/.pi/agent/memory.json`) or the p
 | `memIndexMaxBytes` | `25600` | Max bytes in `MEMORY.md` before capacity errors |
 | `defaults.model` | — | Shared model fallback for all sub-tasks. Per-task `model` overrides |
 | `defaults.sessionPersistence.enabled` | `false` | Shared session persistence fallback (default: in-memory). Per-task overrides |
-| `defaults.sessionPersistence.sessionDir` | `memoryDir/sessions/` | Custom session directory for persisted headless agent sessions |
+| `defaults.sessionPersistence.sessionDir` | `<project memory dir>/sessions/` | Custom session directory for persisted headless agent sessions |
 | `dream.nudgeAfterSessions` | `5` | Sessions since last dream before nudge is shown |
 | `dream.nudgeAfterHours` | `24` | Hours since last dream before nudge is shown |
 | `dream.model` | — | Model for dream consolidation (`"provider/id"`). Falls back to `defaults.model` → parent model |
 | `dream.thinkLevel` | `"high"` | Thinking effort for dream subagent: `"off"`, `"minimal"`, `"low"`, `"medium"`, `"high"`, `"xhigh"` |
 | `dream.sessionPersistence.enabled` | `false` | Persist dream agent sessions to disk (debug/audit). Falls back to `defaults.sessionPersistence.enabled` |
-| `dream.sessionPersistence.sessionDir` | `memoryDir/sessions/` | Custom session directory for dream sessions |
+| `dream.sessionPersistence.sessionDir` | `<project memory dir>/sessions/` | Custom session directory for dream sessions |
 | `sessionSearch.maxSessions` | `10` | Max sessions to scan when searching history |
 | `sessionSearch.maxMatches` | `5` | Max matches to return from history search |
 | `autoSurfacing.enabled` | `true` | ⭐ Enable per-turn topic file auto-injection |
@@ -108,6 +108,8 @@ Create `memory.json` in the agent directory (`~/.pi/agent/memory.json`) or the p
 | `extractMemories.sessionPersistence.enabled` | `false` | Persist extract agent sessions to disk. Falls back to `defaults.sessionPersistence.enabled` |
 | `extractMemories.maxContextTokens` | `2000` | ⭐ Max tokens of conversation to analyze |
 
+Persisted headless agent sessions default to `<project memory dir>/sessions/` — inside the project's memory directory, not inside your working copy. For example `~/.pi/memory/git/github.com__owner__repo/sessions/`.
+
 Project-level config (`.pi/memory.json`) is only loaded when the project is trusted.
 
 ## How it works
@@ -230,15 +232,30 @@ A confirmation dialog is shown before the consolidation begins. The result summa
 
 ```
 ~/.pi/memory/
-  <12-char-sha256>/
-    MEMORY.md            — compact index: one line per topic file
-    .dream-meta.json     — last dream timestamp + session count
-    debugging.md         — topic files with frontmatter + ## entries
-    preferences.md
-    ...
+  git/
+    github.com__yandy__pi-packages/    ← https://github.com/yandy/pi-packages.git
+      MEMORY.md            — compact index: one line per topic file
+      .dream-meta.json     — last dream timestamp + session count
+      debugging.md         — topic files with frontmatter + ## entries
+      preferences.md
+      ...
+  local/
+    home__yandy__workspace__scratch/   ← non-git directory /home/yandy/workspace/scratch
 ```
 
-The hash is derived from the project's git root (or absolute path), ensuring each project gets its own memory namespace.
+Directory names are derived as follows:
+
+- git repos whose remote is http(s), ssh (including scp-style `[user@]host:owner/repo`, where the user is optional) or `git://`, plus the `git+ssh://` / `git+https://` aliases → `git/<host>__<owner>__<repo>`; port, credentials, trailing `/` and `.git` are stripped and the host is lowercased
+- remote URLs are read from the raw git config (`remote.<name>.url`; `origin` first, then alphabetical, first usable URL wins), so `url.*.insteadOf` rewrites do not change the mapping
+- scheme forms apply WHATWG URL normalization (IDN hosts become punycode, percent-encoding and `.`/`..` folding apply, credentials/queries/fragments are dropped), while scp forms keep the path as written — equivalent remotes written differently can map to different directories
+- everything else — non-git directories, git repos without a remote, `file://` or local-path remotes → `local/<absolute-path>` (git repos use the repository root; a Windows-style drive-letter remote such as `C:/repos/foo.git` is treated as scp-style on POSIX, matching git)
+- `/` becomes `__`; characters that are not portable in file names (`<>:"|?*`, control characters) become `_XX` hex escapes
+- names longer than 120 UTF-8 bytes are truncated to 100 bytes on a code-point boundary plus a `__<hash8>` suffix
+- names target POSIX filesystems: a backslash is an ordinary character, and no Windows device-name or trailing-dot handling is applied
+
+The mapping is not injective: underscores are kept as-is, so `/home/a__b` and `/home/a/b` both map to `home__a__b` (and share one memory directory). Changing or renaming a remote, adding a remote that sorts before the one currently in use, or moving a local directory changes the memory directory, orphaning the old one.
+
+**Legacy layout:** earlier versions stored memory under `~/.pi/memory/<12-char-sha256>/`; those directories are no longer read or written. To migrate a project manually, compute the old hash with `printf '%s' "$(git rev-parse --show-toplevel)" | sha256sum | cut -c1-12` (use `$PWD` outside a git repo), then `mv` that directory to the new location (run `/memory` inside the project to see the new path).
 
 ## Snapshot semantics
 

package/README.zh.md

@@ -1,6 +1,6 @@
 # pi-memory
 
-基于文件系统的持久化记忆层，为 pi 编程代理提供跨会话的项目记忆。事实、偏好、调试历史等知识以纯 Markdown 文件形式存储在 `~/.pi/memory/<项目哈希>/` 下。
+基于文件系统的持久化记忆层，为 pi 编程代理提供跨会话的项目记忆。事实、偏好、调试历史等知识以纯 Markdown 文件形式存储在 `~/.pi/memory/<git|local>/<项目>/` 下。
 
 对齐 Claude Code 的 auto memory 机制：每 topic 一行的 MEMORY.md 紧凑索引、基于相关性的 topic 文件自动注入、per-turn 记忆自动提取、类型化记忆分类。
 
@@ -17,7 +17,7 @@
 - **梦醒提醒**：经过 N 个会话或 N 小时后，温和通知建议运行 `/dream`
 - **`/memory` 命令**：查看状态、开关记忆、检查索引和主题文件
 - **会话搜索**：`memory search scope=sessions` 操作可检索过往对话历史
-- **分支安全**：记忆目录以 git 根目录为键，分叉仓库自然共享记忆
+- **可读且 clone 安全**：有 http(s)/ssh/git remote（含 scp 式与 `git+ssh`/`git+https`）的仓库记忆存放在 `~/.pi/memory/git/<host__owner__repo>/`，其余项目存放在 `~/.pi/memory/local/<绝对路径>/` — 同一仓库的 clone、worktree 共享记忆（fork 有自己的 remote，因此拥有独立目录）
 - **路径穿越防护**：主题文件路径会验证是否逃逸记忆目录
 
 ## 安装
@@ -86,13 +86,13 @@ pi install npm:@yandy0725/pi-memory
 | `memIndexMaxBytes` | `25600` | `MEMORY.md` 最大字节数 |
 | `defaults.model` | — | 所有子任务共享的模型回退值。per-task `model` 会覆盖 |
 | `defaults.sessionPersistence.enabled` | `false` | 共享的 session 持久化回退（默认不持久化）。per-task 可覆盖 |
-| `defaults.sessionPersistence.sessionDir` | `memoryDir/sessions/` | 自定义持久化目录 |
+| `defaults.sessionPersistence.sessionDir` | `<项目记忆目录>/sessions/` | 自定义持久化目录 |
 | `dream.nudgeAfterSessions` | `5` | 触发提醒需经过的会话数 |
 | `dream.nudgeAfterHours` | `24` | 触发提醒需经过的小时数 |
 | `dream.model` | — | 整理使用的模型（`"provider/id"`）。回退链：per-task → `defaults.model` → 父模型 |
 | `dream.thinkLevel` | `"high"` | 整理子 agent 的思考深度：`"off"` / `"minimal"` / `"low"` / `"medium"` / `"high"` / `"xhigh"` |
 | `dream.sessionPersistence.enabled` | `false` | 持久化 dream agent 的 session 到磁盘（调试/审计）。回退到 `defaults.sessionPersistence.enabled` |
-| `dream.sessionPersistence.sessionDir` | `memoryDir/sessions/` | dream session 自定义目录 |
+| `dream.sessionPersistence.sessionDir` | `<项目记忆目录>/sessions/` | dream session 自定义目录 |
 | `sessionSearch.maxSessions` | `10` | 搜索历史时最多扫描的会话数 |
 | `sessionSearch.maxMatches` | `5` | 历史搜索最多返回的匹配数 |
 | `autoSurfacing.enabled` | `true` | ⭐ 启用 per-turn topic 文件自动注入 |
@@ -108,6 +108,8 @@ pi install npm:@yandy0725/pi-memory
 | `extractMemories.sessionPersistence.enabled` | `false` | 持久化 extract agent 的 session。回退到 `defaults.sessionPersistence.enabled` |
 | `extractMemories.maxContextTokens` | `2000` | ⭐ 分析对话的最大 token 数 |
 
+持久化的无头 agent session 默认落在 `<项目记忆目录>/sessions/` —— 位于项目的记忆目录内，而非你的代码工作目录，例如 `~/.pi/memory/git/github.com__owner__repo/sessions/`。
+
 项目级配置（`.pi/memory.json`）仅在项目受信任时加载。
 
 ## 工作原理
@@ -228,15 +230,30 @@ memory(action: "add" | "remove" | "search",
 
 ```
 ~/.pi/memory/
-  <12位sha256哈希>/
-    MEMORY.md            — 紧凑索引：每个 topic 文件一行
-    .dream-meta.json     — 上次整理的时间戳和会话计数
-    debugging.md         — topic 文件（frontmatter + ## 条目）
-    preferences.md
-    ...
+  git/
+    github.com__yandy__pi-packages/    ← https://github.com/yandy/pi-packages.git
+      MEMORY.md            — 紧凑索引：每个 topic 文件一行
+      .dream-meta.json     — 上次整理的时间戳和会话计数
+      debugging.md         — topic 文件（frontmatter + ## 条目）
+      preferences.md
+      ...
+  local/
+    home__yandy__workspace__scratch/   ← 非 git 目录 /home/yandy/workspace/scratch
 ```
 
-哈希值由项目的 git 根目录（或绝对路径）派生，每个项目拥有独立记忆命名空间。
+目录名的派生规则：
+
+- remote 为 http(s)、ssh（含 scp 式 `[user@]host:owner/repo`，user 可省略）或 `git://`，以及 `git+ssh://` / `git+https://` 别名的 git 仓库 → `git/<host>__<owner>__<repo>`；端口、认证信息、尾部 `/` 与 `.git` 均被剥离，host 转小写
+- remote URL 读取自原始 git 配置（`remote.<name>.url`；`origin` 优先，其余按字母序，取首个可归一化者），因此 `url.*.insteadOf` 重写不会改变映射结果
+- scheme 形式经 WHATWG URL 归一化（IDN host 转 punycode、应用百分号编码与 `.`/`..` 折叠、凭据/query/fragment 被剔除），scp 形式则保留原样路径 —— 因此同一仓库的不同写法可能落到不同目录
+- 其余情况 —— 非 git 目录、无 remote 的 git 仓库、`file://` 或本地路径 remote → `local/<绝对路径>`（git 仓库取仓库根目录；Windows 风格盘符 remote 如 `C:/repos/foo.git` 在 POSIX 上按 scp 式远端处理，与 git 行为一致）
+- `/` 转为 `__`；文件名不安全的字符（`<>:"|?*`、控制字符）转为 `_XX` 十六进制转义
+- 目录名超过 120 UTF-8 字节时按码点截取前 100 字节并追加 `__<hash8>` 后缀
+- 命名面向 POSIX 文件系统：反斜杠视为普通字符，不做 Windows 设备名或结尾点/空格处理
+
+该映射不是单射：下划线保持原样，因此 `/home/a__b` 与 `/home/a/b` 都会映射为 `home__a__b`（共享同一记忆目录）。修改或重命名 remote、新增一个排序在当前使用的 remote 之前的 remote、或移动本地目录，都会改变记忆目录，旧目录将成为孤儿。
+
+**旧版布局**：早期版本把记忆存放在 `~/.pi/memory/<12位sha256>/` 下，这些目录不再被读取或写入。如需手动迁移，用 `printf '%s' "$(git rev-parse --show-toplevel)" | sha256sum | cut -c1-12` 计算旧哈希（非 git 项目改用 `$PWD`），把对应目录 `mv` 到新路径（在项目里执行 `/memory` 可查看新路径）。
 
 ## 快照语义
 

package/index.ts

@@ -46,7 +46,7 @@ export default function (pi: ExtensionAPI) {
 		config = await loadConfig(ctx);
 		if (!config.enabled) return;
 		memoryDir = await resolveMemoryDir(config, ctx.cwd);
-		indexSnapshot = await loadIndexSnapshot(memoryDir, config.memIndexMaxLines, config.memIndexMaxBytes);
+		indexSnapshot = await loadIndexSnapshot(memoryDir, config.memIndexInjectMaxLines, config.memIndexInjectMaxBytes);
 
 		// register memory tool once
 		if (!toolRegistered) {

package/package.json

@@ -3,7 +3,7 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"version": "1.3.3",
+	"version": "1.4.0",
 	"description": "File-system driven persistent memory layer for pi coding agent",
 	"license": "MIT",
 	"repository": {
@@ -38,6 +38,10 @@
 		"typebox": "*"
 	},
 	"devDependencies": {
-		"typebox": "^1.3.3"
+		"@biomejs/biome": "^2.5.14",
+		"@types/node": "^26.6.2",
+		"typebox": "^1.3.34",
+		"typescript": "~7.0.2",
+		"vitest": "^5.0.1"
 	}
 }

package/src/config.ts

@@ -9,7 +9,7 @@ export type ThinkLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh"
 export interface SessionPersistenceConfig {
 	/** Enable disk persistence (default: false = in-memory). */
 	enabled: boolean;
-	/** Custom session directory. Defaults to memoryDir/sessions/. */
+	/** Custom session directory. Defaults to `<project memory dir>/sessions/` (the resolved per-project directory under `memoryDir`). */
 	sessionDir?: string;
 }
 
@@ -40,8 +40,14 @@ export interface MemoryConfig {
 	/** Shared defaults for model and sessionPersistence. Per-task configs override. */
 	defaults?: DefaultsConfig;
 	memoryDir: string;
+	/** Write capacity: max entries in MEMORY.md index. */
 	memIndexMaxLines: number;
+	/** Write capacity: max bytes of serialized MEMORY.md index. */
 	memIndexMaxBytes: number;
+	/** Injection truncation: max lines of MEMORY.md injected into system prompt. */
+	memIndexInjectMaxLines: number;
+	/** Injection truncation: max bytes of MEMORY.md injected into system prompt. */
+	memIndexInjectMaxBytes: number;
 	dream: {
 		nudgeAfterSessions: number;
 		nudgeAfterHours: number;
@@ -63,14 +69,16 @@ export const DEFAULT_CONFIG: MemoryConfig = {
 	memoryDir: join(homedir(), CONFIG_DIR_NAME, "memory"),
 	memIndexMaxLines: 200,
 	memIndexMaxBytes: 25600,
+	memIndexInjectMaxLines: 20,
+	memIndexInjectMaxBytes: 3072,
 	dream: { nudgeAfterSessions: 5, nudgeAfterHours: 24, thinkLevel: "high" },
 	sessionSearch: { maxSessions: 10, maxMatches: 5 },
 	autoSurfacing: {
 		enabled: true,
 		thinkLevel: "off",
-		maxFiles: 5,
-		maxTopicBytes: 4096,
-		maxInjectionBytes: 20480,
+		maxFiles: 3,
+		maxTopicBytes: 3072,
+		maxInjectionBytes: 10240,
 	},
 	extractMemories: {
 		enabled: true,

package/src/paths.ts

@@ -4,24 +4,176 @@ import { join, normalize, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 
 const execFileP = promisify(execFile);
+const GIT_TIMEOUT_MS = 3000;
 
 async function gitToplevel(cwd: string): Promise<string | null> {
 	try {
-		const { stdout } = await execFileP("git", ["rev-parse", "--show-toplevel"], { cwd, timeout: 3000 });
+		const { stdout } = await execFileP("git", ["rev-parse", "--show-toplevel"], { cwd, timeout: GIT_TIMEOUT_MS });
 		return stdout.trim() || null;
 	} catch {
 		return null;
 	}
 }
 
-export async function projectHash(cwd: string): Promise<string> {
-	const key = (await gitToplevel(cwd)) ?? resolve(cwd);
-	return createHash("sha256").update(key).digest("hex").slice(0, 12);
+const DIR_NAME_MAX_BYTES = 120;
+const DIR_NAME_KEEP_BYTES = 100;
+const HASH_LENGTH = 8;
+// biome-ignore lint/suspicious/noControlCharactersInRegex: intentionally matching C0 control characters for path escaping
+const ILLEGAL_SEGMENT_CHARS = /[<>:"|?*\x00-\x1f]/g;
+
+/** Escape characters that are unsafe in a single filesystem path segment. */
+function escapeSegment(segment: string): string {
+	return segment.replace(ILLEGAL_SEGMENT_CHARS, (ch) => `_${ch.charCodeAt(0).toString(16).padStart(2, "0")}`);
+}
+
+/** Truncate to at most `maxBytes` UTF-8 bytes on grapheme-cluster boundaries. */
+const GRAPHEME_SEGMENTER = new Intl.Segmenter("en", { granularity: "grapheme" });
+
+function truncateToBytes(input: string, maxBytes: number): string {
+	let kept = "";
+	for (const { segment } of GRAPHEME_SEGMENTER.segment(input)) {
+		if (Buffer.byteLength(kept + segment, "utf8") > maxBytes) break;
+		kept += segment;
+	}
+	return kept;
+}
+
+/**
+ * Encode a project key into a single, human-readable directory name.
+ * `host/repo/path` → `host__repo__path`; `/abs/path` → `abs__path`.
+ * Naming targets POSIX filesystems: `\` is an ordinary character, without
+ * Windows device-name or trailing-dot handling.
+ */
+export function projectDirName(key: string): string {
+	const segments = key
+		.split("/")
+		.filter((segment) => segment !== "" && segment !== "." && segment !== "..")
+		.map(escapeSegment);
+	if (segments.length === 0) return "root";
+	const joined = segments.join("__");
+	// Filesystems cap one name at 255 bytes: count bytes so multi-byte names
+	// (CJK, emoji) cannot exceed the limit, and cut on code point boundaries.
+	if (Buffer.byteLength(joined, "utf8") <= DIR_NAME_MAX_BYTES) return joined;
+	const suffix = createHash("sha256").update(key).digest("hex").slice(0, HASH_LENGTH);
+	return `${truncateToBytes(joined, DIR_NAME_KEEP_BYTES)}__${suffix}`;
+}
+
+export type ProjectKind = "git" | "local";
+
+export interface ProjectIdentity {
+	kind: ProjectKind;
+	/** git: normalized remote as `host/path`; local: absolute project root */
+	key: string;
+}
+
+const GIT_PROTOCOLS = new Set(["http", "https", "ssh", "git"]);
+const SCHEME_URL = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//;
+
+/** Lowercase and IDN-normalize a host the way the URL API does for https. */
+function normalizeHost(host: string): string {
+	try {
+		return new URL(`https://${host}`).hostname;
+	} catch {
+		return host.toLowerCase();
+	}
+}
+
+/**
+ * Normalize an http(s)/ssh/git remote URL to `host/path`.
+ * Accepts `[user@]host:path` scp syntax and `git+ssh` / `git+https` aliases.
+ * Returns null for file:// URLs, local paths and URLs without a repository path.
+ */
+export function normalizeRemoteUrl(url: string): string | null {
+	const raw = url.trim();
+	if (!raw) return null;
+
+	let host: string;
+	let path: string;
+	if (SCHEME_URL.test(raw)) {
+		let parsed: URL;
+		try {
+			parsed = new URL(raw);
+		} catch {
+			return null;
+		}
+		const scheme = parsed.protocol.slice(0, -1).toLowerCase().replace(/^git\+/, "");
+		if (!GIT_PROTOCOLS.has(scheme)) return null;
+		// Non-special schemes (ssh, git) keep an opaque, un-normalized host.
+		host = normalizeHost(parsed.hostname);
+		path = parsed.pathname;
+	} else {
+		// scp-style `[user@]host:path` — git-specific syntax, no stdlib parser.
+		// Split at the first `:` outside a bracketed IPv6 literal.
+		const open = raw.indexOf("[");
+		const close = open === -1 ? -1 : raw.indexOf("]", open);
+		if (open !== -1 && close === -1) return null;
+		const colon = raw.indexOf(":", close === -1 ? 0 : close + 1);
+		if (colon === -1) return null;
+		const authority = raw.slice(0, colon);
+		if (!authority || authority.includes("/")) return null;
+		const at = authority.lastIndexOf("@");
+		host = normalizeHost(at === -1 ? authority : authority.slice(at + 1));
+		path = raw.slice(colon + 1);
+	}
+
+	if (!host) return null;
+	path = path.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "");
+	if (!path) return null;
+	return `${host}/${path}`;
+}
+
+interface RemoteEntry {
+	name: string;
+	url: string;
+}
+
+/**
+ * Read every remote URL from the raw git config, in identity order:
+ * `origin` first, then alphabetical. `url.*.insteadOf` rewrites do not apply here.
+ */
+async function gitRemoteUrls(cwd: string): Promise<RemoteEntry[]> {
+	try {
+		const { stdout } = await execFileP("git", ["config", "--get-regexp", "^remote\\..*\\.url$"], {
+			cwd,
+			timeout: GIT_TIMEOUT_MS,
+		});
+		const byName = new Map<string, string>();
+		for (const line of stdout.split("\n")) {
+			const sep = line.indexOf(" ");
+			if (sep === -1) continue;
+			const key = line.slice(0, sep);
+			if (!key.startsWith("remote.") || !key.endsWith(".url")) continue;
+			const name = key.slice("remote.".length, -".url".length);
+			const url = line.slice(sep + 1).trim();
+			// First URL per remote wins, matching git's fetch-URL precedence.
+			if (!name || !url || byName.has(name)) continue;
+			byName.set(name, url);
+		}
+		const entries = [...byName].map(([name, url]) => ({ name, url }));
+		entries.sort((a, b) => {
+			if ((a.name === "origin") !== (b.name === "origin")) return a.name === "origin" ? -1 : 1;
+			return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+		});
+		return entries;
+	} catch {
+		return [];
+	}
+}
+
+/** Resolve the project identity: normalized git remote, or the project root path. */
+export async function projectIdentity(cwd: string): Promise<ProjectIdentity> {
+	const toplevel = await gitToplevel(cwd);
+	if (!toplevel) return { kind: "local", key: resolve(cwd) };
+	for (const { url } of await gitRemoteUrls(cwd)) {
+		const key = normalizeRemoteUrl(url);
+		if (key) return { kind: "git", key };
+	}
+	return { kind: "local", key: resolve(toplevel) };
 }
 
 export async function resolveMemoryDir(config: { memoryDir: string }, cwd: string): Promise<string> {
-	const hash = await projectHash(cwd);
-	return join(config.memoryDir, hash);
+	const { kind, key } = await projectIdentity(cwd);
+	return join(config.memoryDir, kind, projectDirName(key));
 }
 
 export function safeTopicPath(memoryDir: string, topic: string): string {