dev-memory-cli 0.19.2 → 0.21.0

package/README.md

@@ -151,10 +151,16 @@ apply 写入受 **repo 级队列锁**保护：多个会话可连续发起归档
 | 模式 | 触发条件 | 行为 |
 | --- | --- | --- |
 | 单 repo | cwd 本身是 git 仓库 | 最原始行为，所有 hook/skill 直接作用于当前 repo+branch |
-| Workspace | cwd 不是 git 仓库，但第一级子目录里至少有一个 git 仓库 | SessionStart 为 primary 仓库注入完整记忆 + 其它仓库简短概览；Stop/PreCompact/SessionEnd 对每个仓库各记一次 HEAD；skill 通过 `--repo <basename>` 明确目标仓库，或读 `DEV_ASSETS_PRIMARY_REPO` 作为默认 |
+| Workspace | cwd 不是 git 仓库，但第一级子目录里至少有一个 git 仓库 | SessionStart 为 primary 仓库注入完整记忆 + 其它仓库按数量动态精简的 brief；Stop/PreCompact/SessionEnd 对每个仓库各记一次 HEAD；skill 通过 `--repo <basename>` 明确目标仓库 |
 | No-git | cwd 不是 git 仓库，也不是 workspace | 在当前目录落一个 `.dev-memory-id` dotfile 作为仓库身份，分支层退化成单一共享层（sentinel `_no_git`），`dev-memory-graduate` 此模式下直接拒绝 |
 
-`DEV_ASSETS_PRIMARY_REPO` 接受**仓库目录 basename**（不是绝对路径）。
+Primary 仓库优先读 `DEV_MEMORY_PRIMARY_REPO` / `DEV_ASSETS_PRIMARY_REPO` 环境变量；未设置时读 workspace 根目录下的 `.dev-memory-workspace.json`：
+
+```bash
+dev-memory-cli workspace primary <repo-basename>
+```
+
+`<repo-basename>` 是仓库目录名，不是绝对路径。环境变量适合临时覆盖；`.dev-memory-workspace.json` 适合多个 workspace 各自保存不同 primary。
 
 ## 存储布局
 

package/bin/dev-memory.js

@@ -8,6 +8,7 @@ const os = require("node:os");
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
 const DEFAULT_STORAGE_ROOT = path.join(os.homedir(), ".dev-memory", "repos");
 const DEFAULT_CONFIG_PATH = process.env.DEV_MEMORY_CONFIG_PATH || path.join(os.homedir(), ".dev-memory", "config.json");
+const WORKSPACE_CONFIG_NAME = ".dev-memory-workspace.json";
 
 function fail(message) {
   process.stderr.write(`ERROR: ${message}\n`);
@@ -281,6 +282,74 @@ function commandUi(_positional, options) {
   start({ host, port, openBrowserFlag, readOnly });
 }
 
+function listWorkspaceRepos(workspaceRoot) {
+  if (!fs.existsSync(workspaceRoot) || !fs.statSync(workspaceRoot).isDirectory()) {
+    return [];
+  }
+  return fs.readdirSync(workspaceRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(workspaceRoot, entry.name))
+    .filter((entryPath) => fs.existsSync(path.join(entryPath, ".git")))
+    .sort((a, b) => path.basename(a).localeCompare(path.basename(b)));
+}
+
+function readWorkspaceConfig(workspaceRoot) {
+  const configPath = path.join(workspaceRoot, WORKSPACE_CONFIG_NAME);
+  if (!fs.existsSync(configPath)) return {};
+  const data = loadJson(configPath);
+  return data && typeof data === "object" && !Array.isArray(data) ? data : {};
+}
+
+function commandWorkspace(rawArgs) {
+  const sub = rawArgs[0];
+  const { positional, options } = parseArgs(rawArgs.slice(1));
+  const workspaceRoot = path.resolve(options.workspace || options.repo || process.cwd());
+  const repos = listWorkspaceRepos(workspaceRoot);
+  const repoNames = repos.map((repoPath) => path.basename(repoPath));
+
+  if (!sub || sub === "--help" || sub === "-h") {
+    process.stdout.write(`Usage:
+  dev-memory-cli workspace show [--workspace PATH]
+  dev-memory-cli workspace primary <repo-basename> [--workspace PATH]
+`);
+    return;
+  }
+
+  if (sub === "show") {
+    const config = readWorkspaceConfig(workspaceRoot);
+    process.stdout.write(`${JSON.stringify({
+      workspace: workspaceRoot,
+      config_path: path.join(workspaceRoot, WORKSPACE_CONFIG_NAME),
+      primary_repo: config.primary_repo || null,
+      repos: repoNames,
+    }, null, 2)}\n`);
+    return;
+  }
+
+  if (sub === "primary") {
+    const primary = positional[0];
+    if (!primary || primary === true) {
+      fail("workspace primary requires a repo basename");
+    }
+    if (!repoNames.includes(primary)) {
+      fail(`repo '${primary}' not found under ${workspaceRoot}. Available: ${repoNames.join(", ") || "(none)"}`);
+    }
+    const configPath = path.join(workspaceRoot, WORKSPACE_CONFIG_NAME);
+    const config = readWorkspaceConfig(workspaceRoot);
+    config.primary_repo = primary;
+    config.updated_at = new Date().toISOString();
+    writeJson(configPath, config);
+    process.stdout.write(`${JSON.stringify({
+      workspace: workspaceRoot,
+      config_path: configPath,
+      primary_repo: primary,
+    }, null, 2)}\n`);
+    return;
+  }
+
+  fail(`unknown workspace command: ${sub}`);
+}
+
 // Subcommands that delegate straight to the Python lib/ scripts.
 // Their CLIs (subcommands, flags) are owned by argparse on the Python
 // side, so we deliberately bypass parseArgs and forward raw argv.
@@ -617,6 +686,7 @@ function printHelp() {
   dev-memory-cli install-hooks <codex|claude> [--repo PATH] [--global]
   dev-memory-cli install-hooks --all [--repo PATH] [--global]
   dev-memory-cli ui [--port N] [--host HOST] [--no-open] [--read-only]
+  dev-memory-cli workspace <show|primary> [...]
   dev-memory-cli read <show|search> [...]
   dev-memory-cli context <show|...> [...]
   dev-memory-cli capture <record|show|sync-working-tree|record-head|suggest-kind|classify> [...]
@@ -662,6 +732,10 @@ function main() {
     commandUi(positional, options);
     return;
   }
+  if (command === "workspace") {
+    commandWorkspace(argv.slice(1));
+    return;
+  }
   fail(`unknown command: ${command}`);
 }
 

package/lib/dev_memory_capture.py

@@ -162,6 +162,20 @@ SUPERSEDES_KEYWORDS = (
 _SIM_PREVIEW_LEN = 80
 
 
+def _int_env(name, default):
+    value = os.environ.get(name, "").strip()
+    if not value:
+        return default
+    try:
+        return int(value)
+    except ValueError:
+        return default
+
+
+_REPO_SHARED_MAX_ENTRIES = _int_env("DEV_MEMORY_REPO_SHARED_MAX_ENTRIES", 20)
+_REPO_SHARED_MAX_ENTRY_CHARS = _int_env("DEV_MEMORY_REPO_SHARED_MAX_ENTRY_CHARS", 260)
+
+
 def _first_nonempty_line(text):
     """Return the first non-blank line of `text`, stripped. Empty string if
     `text` is all blank. Used as the comparison anchor for similarity_check
@@ -435,6 +449,121 @@ def _check_dedup_for_kind(paths, kind, body, force=False, title_override=None, t
     return _build_dedup_hint(kind, file_key, section_title, body, matches)
 
 
+def _iter_search_targets(kind=None):
+    seen = set()
+    if kind:
+        spec = KIND_MAP.get(kind)
+        if not spec:
+            raise RuntimeError(f"unsupported kind: {kind}")
+        if spec.get("default_mode") != "append":
+            raise RuntimeError(f"kind {kind!r} is not append-style and cannot be searched for entry candidates")
+        targets = [(kind, spec)]
+    else:
+        targets = sorted(KIND_MAP.items())
+    for kind_name, spec in targets:
+        if spec.get("default_mode") != "append":
+            continue
+        file_key = spec["file"]
+        section_title = spec["section"]
+        key = (file_key, section_title)
+        if key in seen:
+            continue
+        seen.add(key)
+        yield kind_name, file_key, section_title
+
+
+def _score_candidate(query, entry_text):
+    query = (query or "").strip()
+    if not query:
+        return 0.0
+    query_key = _strip_bullet_prefix(_first_nonempty_line(query))[:_SIM_PREVIEW_LEN]
+    first_key = _strip_bullet_prefix(_first_nonempty_line(entry_text))[:_SIM_PREVIEW_LEN]
+    full_key = " ".join(_strip_bullet_prefix(entry_text).split())[: max(_SIM_PREVIEW_LEN * 3, 1)]
+    first_ratio = difflib.SequenceMatcher(None, query_key, first_key).ratio() if first_key else 0.0
+    full_ratio = difflib.SequenceMatcher(None, query_key, full_key).ratio() if full_key else 0.0
+    return round(max(first_ratio, full_ratio), 4)
+
+
+def find_entry_candidates(paths, query, *, kind=None, limit=8, min_score=0.2):
+    """Search existing append-style memory entries for a correction target.
+
+    This is intentionally broader than dedup. Dedup protects append writes
+    from near duplicates in a single target section; correction workflows need
+    a read-only way to locate the old entry even when the replacement text is
+    not similar enough to trip the append-time threshold.
+    """
+    if not (query or "").strip():
+        raise RuntimeError("one of --query / --query-file is required")
+    candidates = []
+    for _kind_name, file_key, section_title in _iter_search_targets(kind):
+        target_path = paths[file_key]
+        if not target_path.exists():
+            continue
+        content = target_path.read_text(encoding="utf-8")
+        _prefix, sections = split_sections(content)
+        for section_idx, (title, body) in enumerate(sections):
+            if title.strip() != section_title.strip():
+                continue
+            for entry_idx, entry_text in _section_top_level_entries(body):
+                if _is_placeholder_entry(entry_text):
+                    continue
+                score = _score_candidate(query, entry_text)
+                if score < min_score:
+                    continue
+                candidates.append({
+                    "id": f"{file_key}::{section_idx}::{entry_idx}",
+                    "score": score,
+                    "file": _label(file_key),
+                    "section": title,
+                    "match_first_line": _strip_bullet_prefix(_first_nonempty_line(entry_text)),
+                    "match_full_text": entry_text,
+                })
+    candidates.sort(key=lambda item: item["score"], reverse=True)
+    return candidates[:limit]
+
+
+def list_section_entries(paths, kind, *, limit=80, tail=False):
+    if kind not in KIND_MAP:
+        raise RuntimeError(f"unsupported kind: {kind}")
+    spec = KIND_MAP[kind]
+    file_key = spec["file"]
+    section_title = spec["section"]
+    target_path = paths[file_key]
+    entries = []
+    if target_path.exists():
+        content = target_path.read_text(encoding="utf-8")
+        _prefix, sections = split_sections(content)
+        for section_idx, (title, body) in enumerate(sections):
+            if title.strip() != section_title.strip():
+                continue
+            for entry_idx, entry_text in _section_top_level_entries(body):
+                if _is_placeholder_entry(entry_text):
+                    continue
+                entries.append({
+                    "id": f"{file_key}::{section_idx}::{entry_idx}",
+                    "entry_idx": entry_idx,
+                    "file": _label(file_key),
+                    "section": title,
+                    "first_line": _strip_bullet_prefix(_first_nonempty_line(entry_text)),
+                    "full_text": entry_text,
+                })
+    total = len(entries)
+    if limit is not None:
+        shown = entries[-limit:] if tail else entries[:limit]
+    else:
+        shown = entries
+    return {
+        "kind": kind,
+        "target_file": _label(file_key),
+        "section": section_title,
+        "total_entries": total,
+        "returned_entries": len(shown),
+        "truncated": len(shown) < total,
+        "tail": bool(tail),
+        "entries": shown,
+    }
+
+
 # ---------------------------------------------------------------------------
 # rewrite-entry primitives
 # ---------------------------------------------------------------------------
@@ -892,6 +1021,110 @@ def decision_body(item):
     return "\n".join(parts)
 
 
+def compact_decision_body(item):
+    """Render a repo-shared decision as one short bullet.
+
+    Branch decisions can afford reason/impact substructure because they are
+    read on demand. Repo shared decisions are injected into every branch, so
+    each item must be a compact standalone rule.
+    """
+    summary = _decision_summary(item)
+    if not isinstance(item, dict):
+        return f"- {summary}"
+    extras = []
+    reason = str(item.get("reason") or "").strip()
+    impact = str(item.get("impact") or "").strip()
+    if reason:
+        extras.append(f"原因: {reason}")
+    if impact:
+        extras.append(f"适用: {impact}")
+    suffix = f"（{'；'.join(extras)}）" if extras else ""
+    return f"- {summary}{suffix}"
+
+
+def _compact_repo_shared_entry(entry, max_chars):
+    text = (entry or "").strip()
+    if not text:
+        return ""
+    if len(text) <= max_chars:
+        return text
+    first = _strip_bullet_prefix(_first_nonempty_line(text))
+    if len(first) > max_chars:
+        first = first[: max_chars - 1].rstrip() + "…"
+    return f"- {first}"
+
+
+def _prune_repo_shared_section(path, section_title, *, max_entries, max_entry_chars):
+    if max_entries <= 0:
+        return None
+    content = path.read_text(encoding="utf-8") if path.exists() else ""
+    prefix, sections = split_sections(content)
+    changed = False
+    updated = []
+    result = None
+    for existing_title, existing_body in sections:
+        if existing_title.strip() != section_title.strip():
+            updated.append((existing_title, existing_body))
+            continue
+        entries = [entry for _idx, entry in _section_top_level_entries(existing_body)]
+        if not entries:
+            updated.append((existing_title, existing_body))
+            continue
+        kept = entries[-max_entries:]
+        compacted = [_compact_repo_shared_entry(entry, max_entry_chars) for entry in kept]
+        compacted = [entry for entry in compacted if entry]
+        new_body = "\n\n".join(compacted)
+        pruned_count = max(0, len(entries) - len(kept))
+        if new_body.strip() != existing_body.strip():
+            changed = True
+        result = {
+            "file": "repo/decisions.md" if path.name == "decisions.md" else "repo/glossary.md",
+            "section": existing_title,
+            "mode": "prune",
+            "before": len(entries),
+            "after": len(compacted),
+            "pruned": pruned_count,
+            "max_entries": max_entries,
+            "max_entry_chars": max_entry_chars,
+        }
+        updated.append((existing_title, new_body))
+    if not changed:
+        return None
+    path.write_text(join_sections(prefix, updated), encoding="utf-8")
+    return result
+
+
+def prune_repo_shared_memory(paths, *, max_entries=None, max_entry_chars=None):
+    """Keep repo-shared memory small enough for SessionStart injection.
+
+    This is intentionally deterministic and conservative: newest entries win,
+    each entry is capped to its leading claim, and only repo shared sections are
+    touched. Deeper semantic cleanup still belongs to tidy/graduate.
+    """
+    max_entries = _REPO_SHARED_MAX_ENTRIES if max_entries is None else max_entries
+    max_entry_chars = _REPO_SHARED_MAX_ENTRY_CHARS if max_entry_chars is None else max_entry_chars
+    targets = (
+        ("repo_decisions", "跨分支通用决策"),
+        ("repo_glossary", "长期有效背景"),
+        ("repo_glossary", "共享入口"),
+        ("repo_glossary", "共享注意点"),
+    )
+    touched = []
+    for file_key, section in targets:
+        path = paths.get(file_key)
+        if not path:
+            continue
+        rec = _prune_repo_shared_section(
+            path,
+            section,
+            max_entries=max_entries,
+            max_entry_chars=max_entry_chars,
+        )
+        if rec:
+            touched.append(rec)
+    return touched
+
+
 # ---------------------------------------------------------------------------
 # Write primitives
 # ---------------------------------------------------------------------------
@@ -1093,6 +1326,68 @@ def command_classify(args):
     return 0
 
 
+def command_find_candidates(args):
+    repo_root, branch_name, branch_key, storage_root, repo_key, repo_dir, branch_dir, paths = ensure_branch_paths_exist(
+        args.repo, args.context_dir, args.branch
+    )
+    query = _load_optional_text(args.query, args.query_file)
+    if not query:
+        raise RuntimeError("one of --query / --query-file is required")
+    min_score = getattr(args, "min_score", 0.2)
+    if not (0.0 <= min_score <= 1.0):
+        raise RuntimeError(f"--min-score must be in [0.0, 1.0], got {min_score}")
+    if args.limit < 1:
+        raise RuntimeError(f"--limit must be >= 1, got {args.limit}")
+    candidates = find_entry_candidates(
+        paths,
+        query,
+        kind=args.kind,
+        limit=args.limit,
+        min_score=min_score,
+    )
+    print(json.dumps({
+        "repo_root": str(repo_root),
+        "repo_key": repo_key,
+        "branch": branch_name,
+        "storage_root": str(storage_root),
+        "branch_dir": str(branch_dir),
+        "mode": "find-candidates",
+        "query_preview": _first_nonempty_line(query)[:_SIM_PREVIEW_LEN],
+        "kind": args.kind,
+        "candidates": candidates,
+        "next_actions": [
+            "同一旧条目需要更新: dev-memory-cli capture rewrite-entry --id <id> --content '<new text>'",
+            "旧条目应移除: dev-memory-cli capture delete-entry --id <id>",
+            "没有对应旧条目: dev-memory-cli capture record --kind <kind> --content '<new text>'",
+        ],
+    }, ensure_ascii=False, indent=2))
+    return 0
+
+
+def command_list_entries(args):
+    repo_root, branch_name, branch_key, storage_root, repo_key, repo_dir, branch_dir, paths = ensure_branch_paths_exist(
+        args.repo, args.context_dir, args.branch
+    )
+    if args.limit < 1:
+        raise RuntimeError(f"--limit must be >= 1, got {args.limit}")
+    result = list_section_entries(paths, args.kind, limit=args.limit, tail=args.tail)
+    print(json.dumps({
+        "repo_root": str(repo_root),
+        "repo_key": repo_key,
+        "branch": branch_name,
+        "storage_root": str(storage_root),
+        "branch_dir": str(branch_dir),
+        "mode": "list-entries",
+        **result,
+        "next_actions": [
+            "同一旧条目需要更新: dev-memory-cli capture rewrite-entry --id <id> --content '<new text>'",
+            "旧条目应移除: dev-memory-cli capture delete-entry --id <id>",
+            "没有对应旧条目: dev-memory-cli capture record --kind <kind> --content '<new text>'",
+        ],
+    }, ensure_ascii=False, indent=2))
+    return 0
+
+
 def command_record(args):
     repo_root, branch_name, branch_key, storage_root, repo_key, repo_dir, branch_dir, paths = ensure_branch_paths_exist(
         args.repo, args.context_dir, args.branch
@@ -1215,7 +1510,7 @@ def command_record(args):
         shared_decision_payload_items = [
             item for item in (payload.get("shared_decisions") or []) if _decision_summary(item)
         ]
-        shared_decision_items = [decision_body(item) for item in shared_decision_payload_items]
+        shared_decision_items = [compact_decision_body(item) for item in shared_decision_payload_items]
         if shared_decision_items:
             body = "\n\n".join(shared_decision_items)
             rec = _write_or_block("shared-decision", body, source_label="payload[shared_decisions]")
@@ -1550,7 +1845,7 @@ def command_apply_summary_output(args):
     for item in payload.get("glossary") or []:
         add_write("glossary", item, source="glossary")
     for item in payload.get("shared_decisions") or []:
-        add_write("shared-decision", _decision_content(item), source="shared_decisions")
+        add_write("shared-decision", compact_decision_body(item), source="shared_decisions")
     for item in payload.get("shared_context") or []:
         add_write("shared-context", item, source="shared_context")
     for item in payload.get("shared_sources") or []:
@@ -1599,6 +1894,21 @@ def command_apply_summary_output(args):
             "reason": item.get("reason"),
         })
 
+    pruned = prune_repo_shared_memory(paths)
+    if pruned:
+        touched.extend(pruned)
+        for rec in pruned:
+            actions.append({
+                "op": "prune-repo-shared",
+                "file": rec["file"],
+                "section": rec["section"],
+                "before": rec["before"],
+                "after": rec["after"],
+                "pruned": rec["pruned"],
+                "max_entries": rec["max_entries"],
+                "max_entry_chars": rec["max_entry_chars"],
+            })
+
     updated_at = now_iso()
 
     if touched:
@@ -1813,6 +2123,27 @@ def main():
     classify.add_argument("--content", help="Inline content to classify")
     classify.add_argument("--content-file", help="File containing content to classify")
 
+    list_entries = subparsers.add_parser(
+        "list-entries",
+        help="List existing entries in a kind's target section with rewrite/delete ids",
+    )
+    _add_common_args(list_entries)
+    list_entries.add_argument("--kind", required=True, help=f"Kind whose target section should be listed. One of: {', '.join(sorted(KIND_MAP.keys()))}")
+    list_entries.add_argument("--limit", type=int, default=80, help="Maximum number of entries to return")
+    list_entries.add_argument("--tail", action="store_true", help="Return the newest entries instead of the oldest when limited")
+
+    find_candidates = subparsers.add_parser(
+        "find-candidates",
+        help="Find existing entries that a correction should rewrite/delete before appending",
+    )
+    append_kinds = [name for name, spec in sorted(KIND_MAP.items()) if spec.get("default_mode") == "append"]
+    _add_common_args(find_candidates)
+    find_candidates.add_argument("--query", help="Inline text describing the old entry to find")
+    find_candidates.add_argument("--query-file", help="File containing search text")
+    find_candidates.add_argument("--kind", help=f"Restrict search to one append kind. One of: {', '.join(append_kinds)}")
+    find_candidates.add_argument("--limit", type=int, default=8, help="Maximum number of candidates to return")
+    find_candidates.add_argument("--min-score", type=float, default=0.2, help="Minimum fuzzy score in [0.0, 1.0]")
+
     record = subparsers.add_parser("record", help="Write content into one or more sections")
     _add_common_args(record)
     record.add_argument("--kind", help=f"Explicit kind. One of: {', '.join(sorted(KIND_MAP.keys()))}")
@@ -1879,6 +2210,8 @@ def main():
             "show": command_show,
             "suggest-kind": command_suggest_kind,
             "classify": command_classify,
+            "list-entries": command_list_entries,
+            "find-candidates": command_find_candidates,
             "record": command_record,
             "rewrite-entry": command_rewrite_entry,
             "delete-entry": command_delete_entry,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dev-memory-cli",
-  "version": "0.19.2",
+  "version": "0.21.0",
   "description": "CLI for dev-memory hooks and repo-local setup (formerly @xluos/dev-assets-cli)",
   "license": "MIT",
   "repository": {

package/scripts/hooks/_common.py

@@ -41,6 +41,7 @@ CONTEXT_SCRIPT = PACKAGE_ROOT / "lib" / "dev_memory_context.py"
 CAPTURE_SCRIPT = PACKAGE_ROOT / "lib" / "dev_memory_capture.py"
 SUMMARY_WORKER_SCRIPT = PACKAGE_ROOT / "scripts" / "hooks" / "session_summary_worker.py"
 DEFAULT_CONFIG_PATH = Path(os.environ.get("DEV_MEMORY_CONFIG_PATH", "~/.dev-memory/config.json")).expanduser()
+WORKSPACE_CONFIG_NAMES = (".dev-memory-workspace.json", ".dev-assets-workspace.json")
 
 
 def run_python(script_path, *args, cwd=None):
@@ -153,12 +154,30 @@ def list_workspace_repos():
 
 
 def primary_repo_name():
-    """Basename of the focus repo from env; None if unset."""
+    """Basename of the focus repo. Env is a one-off override; otherwise use
+    workspace-local config so different model workspaces can choose different
+    primary repos under the same global hook install.
+    """
     value = (
         os.environ.get("DEV_MEMORY_PRIMARY_REPO", "").strip()
         or os.environ.get("DEV_ASSETS_PRIMARY_REPO", "").strip()
     )
-    return value or None
+    if value:
+        return value
+    for name in WORKSPACE_CONFIG_NAMES:
+        config_path = REPO_ROOT / name
+        try:
+            if not config_path.exists():
+                continue
+            data = json.loads(config_path.read_text(encoding="utf-8"))
+            if not isinstance(data, dict):
+                continue
+            configured = data.get("primary_repo") or data.get("primaryRepo")
+            if isinstance(configured, str) and configured.strip():
+                return configured.strip()
+        except Exception as exc:
+            log(f"[dev-memory] workspace config ignored ({config_path}): {exc}")
+    return None
 
 
 def strip_managed_markers(text):
@@ -341,27 +360,21 @@ def maybe_record_head():
 # "后续继续前要注意"; decisions.md carries "关键决策与原因"; glossary.md carries
 # "当前有效上下文".
 _FULL_SECTION_KEYS = (
-    ("glossary", "分支源资料入口"),
-    ("glossary", "当前有效上下文"),
     ("progress", "功能文件索引"),
     ("progress", "建议优先查看的目录"),
+    ("repo_decisions", None),
+    ("repo_glossary", None),
+    ("glossary", "分支源资料入口"),
     ("overview", "当前目标"),
     ("overview", "范围边界"),
     ("overview", "关键约束"),
+    ("repo_overview", None),
+    ("glossary", "当前有效上下文"),
     ("risks", "阻塞与注意点"),
     ("decisions", "关键决策与原因"),
     ("risks", "后续继续前要注意"),
-    ("repo_overview", None),
-    ("repo_decisions", None),
-    ("repo_glossary", None),
-)
-
-_BRIEF_SECTION_KEYS = (
-    ("overview", "当前目标"),
-    ("glossary", "当前有效上下文"),
 )
 
-
 _RECENT_FIRST_SECTIONS = {
     ("decisions", "关键决策与原因"),
     ("risks", "阻塞与注意点"),
@@ -389,9 +402,46 @@ _REPO_DISPLAY_TITLES = {
     "repo_decisions": "跨分支通用决策",
     "repo_glossary": "仓库共享术语与入口",
 }
+_HIGH_PRIORITY_WRAPPERS = {
+    ("progress", "功能文件索引"): "file_map",
+    ("progress", "建议优先查看的目录"): "read_first_dirs",
+    ("repo_decisions", None): "shared_decisions",
+    ("repo_glossary", None): "long_term_context",
+}
 _REPO_MAX_LINES = 32
 _REPO_MAX_CHARS = 3000
 
+_BRIEF_PROFILES = {
+    "expanded": {
+        ("progress", "功能文件索引"): (128, 12000, False),
+        ("progress", "建议优先查看的目录"): (128, 12000, False),
+        ("repo_decisions", None): (32, 3000, True),
+        ("repo_glossary", None): (32, 3000, True),
+    },
+    "standard": {
+        ("progress", "功能文件索引"): (16, 1600, True),
+        ("progress", "建议优先查看的目录"): (8, 800, False),
+        ("repo_decisions", None): (8, 900, True),
+        ("repo_glossary", None): (8, 900, True),
+    },
+    "minimal": {
+        ("progress", "功能文件索引"): (5, 600, True),
+        ("progress", "建议优先查看的目录"): (5, 600, False),
+    },
+}
+
+
+def brief_profile_for_repo_count(repo_count):
+    if repo_count <= 2:
+        return "expanded"
+    if repo_count <= 5:
+        return "standard"
+    return "minimal"
+
+
+def _brief_section_keys(profile):
+    return tuple(_BRIEF_PROFILES.get(profile, _BRIEF_PROFILES["standard"]).keys())
+
 
 def _extract_sections(paths, keys):
     out = []
@@ -402,11 +452,12 @@ def _extract_sections(paths, keys):
         else:
             body = extract_section(paths[file_key], title)
             display_title = title
-        out.append((display_title, body, file_key))
+        wrapper = _HIGH_PRIORITY_WRAPPERS.get((file_key, title))
+        out.append((display_title, body, file_key, title, wrapper))
     return out
 
 
-def _build_context_from_assets(assets, *, full=True, heading=None):
+def _build_context_from_assets(assets, *, full=True, heading=None, brief_profile="standard"):
     if not assets["branch_dir"].exists():
         # v2: capture lazy-inits on first write, so branch_dir typically
         # exists after any real interaction. Missing here just means no
@@ -419,9 +470,10 @@ def _build_context_from_assets(assets, *, full=True, heading=None):
         return None
 
     paths = assets["paths"]
-    keys = _FULL_SECTION_KEYS if full else _BRIEF_SECTION_KEYS
+    keys = _FULL_SECTION_KEYS if full else _brief_section_keys(brief_profile)
     sections = _extract_sections(paths, keys)
     max_lines, max_chars = (8, 700) if full else (3, 200)
+    brief_limits = _BRIEF_PROFILES.get(brief_profile, _BRIEF_PROFILES["standard"])
 
     parts = []
     no_git = assets.get("branch_name") is None
@@ -437,20 +489,27 @@ def _build_context_from_assets(assets, *, full=True, heading=None):
     # the footer's directory header (.../branches/<branch>/).
 
     any_truncated = False
-    for title, body, file_key in sections:
+    for title, body, file_key, source_title, wrapper in sections:
         if not body:
             continue
-        if full and file_key in _REPO_LEVEL_KEYS:
+        if not full and (file_key, source_title) in brief_limits:
+            eff_lines, eff_chars, prefer_recent = brief_limits[(file_key, source_title)]
+        elif full and file_key in _REPO_LEVEL_KEYS:
             eff_lines, eff_chars = _REPO_MAX_LINES, _REPO_MAX_CHARS
-        elif full and (file_key, title) in _BRANCH_REFERENCE_SECTIONS:
+            prefer_recent = (file_key, source_title) in _RECENT_FIRST_SECTIONS
+        elif full and (file_key, source_title) in _BRANCH_REFERENCE_SECTIONS:
             eff_lines, eff_chars = _BRANCH_REF_MAX_LINES, _BRANCH_REF_MAX_CHARS
+            prefer_recent = (file_key, source_title) in _RECENT_FIRST_SECTIONS
         else:
             eff_lines, eff_chars = max_lines, max_chars
-        if (file_key, title) in _RECENT_FIRST_SECTIONS:
+            prefer_recent = (file_key, source_title) in _RECENT_FIRST_SECTIONS
+        if prefer_recent:
             compacted, truncated = compact_recent_body(body, max_lines=eff_lines, max_chars=eff_chars)
         else:
             compacted, truncated = compact_body(body, max_lines=eff_lines, max_chars=eff_chars)
-        if full and file_key in _REPO_LEVEL_KEYS:
+        if wrapper:
+            block = f"<{wrapper}>\n{compacted}\n</{wrapper}>"
+        elif full and file_key in _REPO_LEVEL_KEYS:
             block = compacted
         else:
             block = f"{title}:\n{compacted}"
@@ -545,7 +604,7 @@ def build_session_start_context():
     return _build_context_from_assets(assets, full=True)
 
 
-def build_context_for_repo(repo_path, *, full=True, is_primary=False):
+def build_context_for_repo(repo_path, *, full=True, is_primary=False, brief_profile="standard"):
     """Build a per-repo context block for workspace-mode SessionStart injection.
     Returns None when the repo has no initialized branch memory or resolution fails.
     """
@@ -562,14 +621,15 @@ def build_context_for_repo(repo_path, *, full=True, is_primary=False):
     heading = (
         f"## {tag}`{Path(repo_path).name}` @ branch `{assets['branch_name']}`"
     )
-    return _build_context_from_assets(assets, full=full, heading=heading)
+    return _build_context_from_assets(assets, full=full, heading=heading, brief_profile=brief_profile)
 
 
 def build_workspace_start_context():
     """SessionStart context for workspace mode. Primary repo gets full memory;
-    others get a brief overview only. Returns None if no initialized repos.
+    others get a dynamically compacted brief context. Returns None if no
+    initialized repos.
 
-    Fallback when DEV_MEMORY_PRIMARY_REPO is unset:
+    Fallback when no env/workspace-local primary is set:
       - Single-repo workspace → that repo is full (user's intent is obvious).
       - Multi-repo workspace  → all brief, so N full dumps can't drown the
         session. Header tells the agent how to promote one to full.
@@ -579,6 +639,7 @@ def build_workspace_start_context():
         return None
     primary = primary_repo_name()
     only_one_repo = len(repos) == 1
+    brief_profile = brief_profile_for_repo_count(len(repos))
     primary_hit = False
     has_brief = False
     sections = []
@@ -591,7 +652,12 @@ def build_workspace_start_context():
             primary_hit = True
         else:
             has_brief = True
-        ctx = build_context_for_repo(repo_path, full=is_primary, is_primary=is_primary)
+        ctx = build_context_for_repo(
+            repo_path,
+            full=is_primary,
+            is_primary=is_primary,
+            brief_profile=brief_profile,
+        )
         if ctx:
             sections.append(ctx)
     if not sections:
@@ -604,7 +670,7 @@ def build_workspace_start_context():
         header_parts.append(f"Primary 仓库：`{primary}` ({status})")
     if has_brief:
         header_parts.append(
-            "_其它仓库按 brief 摘要注入；每个 brief 末尾列出该仓库的完整记忆文件路径，"
+            f"_其它仓库按 brief/{brief_profile} 摘要注入；每个 brief 末尾列出该仓库的完整记忆文件路径，"
             "聚焦时直接 Read 即可（如需 CLI：`dev-memory-cli context show --repo <name>`）。_"
         )
     header = "\n".join(header_parts)
@@ -881,6 +947,14 @@ transcript 过滤（extract-core 已执行；这里是核对规则）：
 - 只在确有新增或更新时写入。没有有效新增时只输出 `skip_reason`，代码会把 job 标记为 skipped。
 - 不要写”当前进展”、”下一步”、”当前阶段”等时效性状态——这些天然会过期；记忆应聚焦稳定的决策、约束、上下文和参考信息。
 
+repo 共享层淘汰规则：
+- `shared_decisions` / `shared_context` / `shared_sources` 是跨分支长期记忆，不是会话归档，也不是分支任务备忘。
+- 只有“以后所有分支都需要优先知道”的规则、背景、入口才写 shared；普通业务细节、一次性调试结论、某分支当前状态写 branch 层或跳过。
+- repo 共享层默认只保留最重要的少量条目（约 10-20 条）；新增 shared 前先看 existing_memory，若旧条目已过时、重复、太长，优先输出 `rewrites` / `deletes` 压缩旧内容。
+- `shared_decisions` 的 summary 必须是一条短完整规则；除非必要，不要填 reason/impact。不要把“结论/原因/影响范围”拆成三条长期条目。
+- `shared_context` / `shared_sources` 每条尽量不超过 1 句；不要把交接说明、模块清单、会议纪要整段塞入 repo 共享层。
+- 代码落盘后还会自动对 repo shared section 做确定性修剪：保留最近约 20 条，单条过长会压成首句。因此你应主动写得精炼，避免重要信息被截断。
+
 file_map（功能文件索引）：
 - 用途：让后续 agent 听到”改下操作弹窗”就能直接定位文件，不用搜索。
 - 每条 label 是业务语义名（页面/弹窗/侧拉/组件/表单等），paths 是对应文件的仓库相对路径。
@@ -898,9 +972,9 @@ file_map（功能文件索引）：
     “decisions”: [{{“summary”: “结论”, “reason”: “为什么”, “impact”: “影响范围”}}],
     “risks”: [“风险/坑/阻塞”],
     “glossary”: [“术语/上下文/命令/外部系统入口”],
-    “shared_decisions”: [{{“summary”: “跨分支规则”, “reason”: “为什么”, “impact”: “适用范围”}}],
-    “shared_context”: [“仓库级长期背景”],
-    “shared_sources”: [“仓库级共享入口”],
+    “shared_decisions”: [{{“summary”: “短句跨分支规则”}}],
+    “shared_context”: [“一句话仓库级长期背景”],
+    “shared_sources”: [“一句话仓库级共享入口”],
     “upserts”: [{{“kind”: “overview”, “content”: “覆盖某个 kind”}}],
     “appends”: [{{“kind”: “decision”, “content”: “追加某个 kind”}}],
     “rewrites”: [{{“id”: “decisions::0::2”, “content”: “新条目”, “reason”: “旧结论失效”}}],