wikifier 4.6.0__tar.gz → 4.6.2__tar.gz

{wikifier-4.6.0/wikifier.egg-info → wikifier-4.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wikifier
-Version: 4.6.0
+Version: 4.6.2
 Summary: Zero-dependency agent-to-agent codebase wiki for LLMs and AI agents. Autonomously maintained via record-change and mark-green for token-efficient lookup of files, dependencies, health, and summaries — across tiny scripts to 50k+ monorepos. Optional MCP server with rich tools for agents.
 Author-email: Aron Amos <aron@example.com>
 Maintainer: Aron Amos

{wikifier-4.6.0 → wikifier-4.6.2}/skills/run.md

@@ -43,8 +43,10 @@ Do **not** open megamodules (`javascript.py`, `import_cache.py`, `bree.py`) to d
 |------|-----|
 | First-run map | `init` → `update-maps` → `health --summary` → `suggest-next` |
 | **Session start (4.6+)** | `session_bootstrap` (or CLI `session-bootstrap`) — one shot: root, health, attention, `actions[]` |
+| **Core tool list** | `list_core_tools` / bootstrap `core_surface` — prefer Core 6; advanced is non-core |
 | Steady-state | `check-changes` (content-honest) → edit 🔴/actionable 🟡 only → `record-change` → wiki → `mark-green` |
-| **Preflight edit** | `prepare_edit` / CLI `prepare-edit <file>` — wiki + status + deps + dependents |
+| **Hash migration** | `seed_source_content_hashes` / CLI `seed-source-hashes` — baseline Greens without mass Yellow |
+| **Preflight edit** | `prepare_edit` / CLI `prepare-edit <file>` — wiki + status + deps + dependents (multi-shape reverse index) |
 | **Why / journal** | `why_file` / `search_journal` — semantic trail, not mtime theater |
 | Lookup Core | `session_bootstrap`, `check_changes`, `prepare_edit`, `suggest_next_actions` (json `actions[]`), `record_change`, `mark_green` |
 | Advanced intel | `get_dependencies`, `get_dependents`, `get_cycles`, barrel/diagnostics — not daily Core |

{wikifier-4.6.0 → wikifier-4.6.2}/tests/test_agent_loop.py

@@ -78,6 +78,52 @@ class TestContentHonestDirty(TempProjectTestCase):
         self.assertIn("Yellow", data3["entries"]["mod.py"]["status"])
         self.assertIn("content", data3["entries"]["mod.py"]["reason"].lower())
 
+    def test_legacy_green_without_hash_rewrite_yellows(self):
+        """Criterion 2: Green with no source_content_hash + real rewrite must Yellow.
+
+        Must not seed post-edit hash and stay Green (post-upgrade / legacy path).
+        """
+        p = self.write("legacy.py", "print('v1')\n")
+        # Legacy Green: upsert only — no source_content_hash baseline
+        health_mod.upsert_entry(self.root, "legacy.py", "🟢 Green", "legacy green no hash")
+        data = health_mod.load_health(self.root)
+        self.assertNotIn("source_content_hash", data["entries"]["legacy.py"] or {})
+        from wikifier import import_cache as ic
+        cache = {}
+        ic.update_file_data(cache, "legacy.py", mtime=1, imports=[], resolved_pairs=[])
+        ic.save_cache(self.root, cache)
+        # Real content rewrite
+        p.write_text("print('v2-rewritten')\n", encoding="utf-8")
+        cache = ic.load_cache(self.root)
+        cache["legacy.py"]["mtime"] = 1  # force dirty vs disk
+        ic.save_cache(self.root, cache)
+        r = cli.check_changes(project_root=self.root)
+        self.assertTrue(r.get("success"), r)
+        self.assertGreaterEqual(int(r.get("changes_detected") or 0), 1)
+        data2 = health_mod.load_health(self.root)
+        ent = data2["entries"]["legacy.py"]
+        self.assertIn("Yellow", ent["status"])
+        # Must not have silently stored the post-edit hash as trusted baseline
+        self.assertNotEqual(
+            ent.get("source_content_hash"),
+            compute_source_content_hash(p),
+            "must not seed post-edit content hash without mark_green",
+        )
+        # After mark_green, baseline is set and further touch-only stays green
+        cli.mark_green("legacy.py", "re-baselined", project_root=self.root)
+        data3 = health_mod.load_health(self.root)
+        self.assertIn("source_content_hash", data3["entries"]["legacy.py"])
+        baseline = data3["entries"]["legacy.py"]["source_content_hash"]
+        cache = ic.load_cache(self.root)
+        cache["legacy.py"]["mtime"] = 1
+        ic.save_cache(self.root, cache)
+        os.utime(p, None)
+        r2 = cli.check_changes(project_root=self.root)
+        self.assertTrue(r2.get("success"), r2)
+        data4 = health_mod.load_health(self.root)
+        self.assertIn("Green", data4["entries"]["legacy.py"]["status"])
+        self.assertEqual(data4["entries"]["legacy.py"]["source_content_hash"], baseline)
+
 
 class TestSessionBootstrapAndSuggest(TempProjectTestCase):
     def test_session_bootstrap_shape(self):
@@ -176,5 +222,107 @@ class TestCliBootstrapEntry(TempProjectTestCase):
         self.assertIn("actions", res)
 
 
+class TestSeedSourceHashes(TempProjectTestCase):
+    def test_seed_then_touch_ok_rewrite_yellows(self):
+        p = self.write("seeded.py", "print(0)\n")
+        health_mod.upsert_entry(self.root, "seeded.py", "🟢 Green", "legacy no hash")
+        data = health_mod.load_health(self.root)
+        self.assertNotIn("source_content_hash", data["entries"]["seeded.py"] or {})
+        res = health_mod.seed_source_content_hashes(self.root, only_green=True)
+        self.assertTrue(res.get("success"), res)
+        self.assertGreaterEqual(int(res.get("seeded") or 0), 1)
+        data2 = health_mod.load_health(self.root)
+        ent = data2["entries"]["seeded.py"]
+        self.assertIn("Green", ent["status"])
+        self.assertTrue(ent.get("source_content_hash"))
+        baseline = ent["source_content_hash"]
+        from wikifier import import_cache as ic
+        cache = {}
+        ic.update_file_data(cache, "seeded.py", mtime=1, imports=[], resolved_pairs=[])
+        ic.save_cache(self.root, cache)
+        os.utime(p, None)
+        cache = ic.load_cache(self.root)
+        cache["seeded.py"]["mtime"] = 1
+        ic.save_cache(self.root, cache)
+        r = cli.check_changes(project_root=self.root)
+        self.assertTrue(r.get("success"), r)
+        data3 = health_mod.load_health(self.root)
+        self.assertIn("Green", data3["entries"]["seeded.py"]["status"])
+        self.assertEqual(data3["entries"]["seeded.py"]["source_content_hash"], baseline)
+        p.write_text("print(99)\n", encoding="utf-8")
+        cache = ic.load_cache(self.root)
+        cache["seeded.py"]["mtime"] = 1
+        ic.save_cache(self.root, cache)
+        r2 = cli.check_changes(project_root=self.root)
+        self.assertTrue(r2.get("success"), r2)
+        self.assertGreaterEqual(int(r2.get("changes_detected") or 0), 1)
+        data4 = health_mod.load_health(self.root)
+        self.assertIn("Yellow", data4["entries"]["seeded.py"]["status"])
+
+
+class TestCoreSurfaceListing(unittest.TestCase):
+    def test_list_core_tools_has_six(self):
+        from wikifier.agent_loop import list_core_tools, CORE_DAILY_NAMES
+        res = list_core_tools()
+        self.assertTrue(res.get("success"))
+        self.assertEqual(res.get("core_count"), 6)
+        names = res.get("core_names") or []
+        for n in (
+            "session_bootstrap", "check_changes", "prepare_edit",
+            "suggest_next_actions", "record_change", "mark_green",
+        ):
+            self.assertIn(n, names)
+        self.assertEqual(names, CORE_DAILY_NAMES)
+        adv = res.get("advanced_intel") or []
+        self.assertTrue(adv)
+        self.assertNotIn("session_bootstrap", adv)  # core not listed as advanced-only
+
+
+class TestPrepareEditReverseShapes(TempProjectTestCase):
+    def test_flat_and_nested_reverse_index(self):
+        self.write("lib/t.py", "x=1\n")
+        health_mod.upsert_entry(self.root, "lib/t.py", "🟢 Green", "ok")
+        from wikifier import import_cache as ic
+        from wikifier.agent_loop import prepare_edit, resolve_dependents_from_cache
+
+        # Flat shape
+        cache_flat = {
+            "lib/t.py": {"mtime": 1, "resolved_pairs": []},
+            "lib/a.py": {"mtime": 1, "resolved_pairs": [{"resolved": "lib/t.py", "resolved_path": "lib/t.py"}]},
+            "_reverse_dependencies": {"lib/t.py": ["lib/a.py", "lib/b.py"]},
+        }
+        deps = resolve_dependents_from_cache(cache_flat, "lib/t.py")
+        self.assertIn("lib/a.py", deps)
+        self.assertIn("lib/b.py", deps)
+        ic.save_cache(self.root, cache_flat)
+        pe = prepare_edit("lib/t.py", project_root=self.root)
+        self.assertTrue(pe.get("success"))
+        self.assertIn("lib/a.py", pe.get("dependents") or [])
+
+        # Nested index shape
+        cache_nest = {
+            "lib/t.py": {"mtime": 1, "resolved_pairs": []},
+            "_reverse_dependencies": {
+                "index": {"lib/t.py": ["lib/nested1.py", "lib/nested2.py"]},
+                "version": 1,
+            },
+        }
+        deps2 = resolve_dependents_from_cache(cache_nest, "lib/t.py")
+        self.assertEqual(set(deps2), {"lib/nested1.py", "lib/nested2.py"})
+        ic.save_cache(self.root, cache_nest)
+        pe2 = prepare_edit("lib/t.py", project_root=self.root)
+        self.assertTrue(pe2.get("success"))
+        self.assertIn("lib/nested1.py", pe2.get("dependents") or [])
+
+        # Dict value shape
+        cache_dict = {
+            "_reverse_dependencies": {
+                "lib/t.py": {"importers": ["lib/from_dict.py"]},
+            }
+        }
+        deps3 = resolve_dependents_from_cache(cache_dict, "lib/t.py")
+        self.assertIn("lib/from_dict.py", deps3)
+
+
 if __name__ == "__main__":
     unittest.main()

{wikifier-4.6.0 → wikifier-4.6.2}/wikifier/__init__.py

@@ -46,6 +46,8 @@ from .cli import (
     prepare_edit,
     search_journal,
     why_file,
+    seed_source_content_hashes,
+    list_core_tools,
 )
 from . import agent_loop
 
@@ -76,4 +78,4 @@ from .contracts import (
     compute_acs_confidence,
 )
 
-__version__ = "4.6.0"
+__version__ = "4.6.2"

{wikifier-4.6.0 → wikifier-4.6.2}/wikifier/agent_loop.py

@@ -21,12 +21,122 @@ import importlib
 
 from .project_root import discover_project_root
 
+# Core daily agent surface (4.6+) — prefer these every session.
+CORE_DAILY_TOOLS: List[Dict[str, str]] = [
+    {"name": "session_bootstrap", "role": "one-shot root + health + attention + actions[]"},
+    {"name": "check_changes", "role": "content-honest dirty / ghosts"},
+    {"name": "prepare_edit", "role": "single-file preflight wiki/status/deps/dependents"},
+    {"name": "suggest_next_actions", "role": "selective work + dispatchable actions[]"},
+    {"name": "record_change", "role": "semantic why after edits"},
+    {"name": "mark_green", "role": "trust + source content-hash baseline"},
+]
+CORE_DAILY_NAMES: List[str] = [t["name"] for t in CORE_DAILY_TOOLS]
+ADVANCED_INTEL_TOOLS: List[str] = [
+    "get_dependencies",
+    "get_dependents",
+    "get_cycles",
+    "get_barrel_reports",
+    "get_resolution_diagnostics",
+    "health",
+    "get_project_status",
+    "get_files_needing_attention",
+    "search_journal",
+    "why_file",
+    "update_maps",
+    "validate",
+]
+
+
+def list_core_tools() -> Dict[str, Any]:
+    """Return Core daily vs advanced intel tool metadata (agents prefer Core)."""
+    return {
+        "success": True,
+        "core_daily": list(CORE_DAILY_TOOLS),
+        "core_names": list(CORE_DAILY_NAMES),
+        "advanced_intel": list(ADVANCED_INTEL_TOOLS),
+        "core_count": len(CORE_DAILY_NAMES),
+        "note": "Use Core every session; advanced remains available but non-core.",
+    }
+
 
 def _health_module():
     """Real health submodule (not the shadowed package attribute function)."""
     return importlib.import_module("wikifier.health")
 
 
+def resolve_dependents_from_cache(cache: Dict[str, Any], rel: str) -> List[str]:
+    """Extract reverse dependents for *rel* from multiple reverse-index shapes.
+
+    Supported:
+      - flat: ``_reverse_dependencies[rel] -> [importers]``
+      - nested index: ``_reverse_dependencies["index"][rel]``
+      - dependents key: ``_reverse_dependencies["dependents"][rel]``
+      - map value dict: ``{rel: {"importers": [...]}}`` or ``{"sources": [...]}``
+      - import_cache.get_reverse_dependencies when available
+    Fallback: scan resolved_pairs for edges pointing at rel.
+    """
+    if not rel or not isinstance(cache, dict):
+        return []
+
+    def _as_list(val: Any) -> List[str]:
+        if val is None:
+            return []
+        if isinstance(val, list):
+            return [str(x) for x in val if x]
+        if isinstance(val, dict):
+            for k in ("importers", "sources", "dependents", "files", "from"):
+                if isinstance(val.get(k), list):
+                    return [str(x) for x in val[k] if x]
+            # keys-as-importers
+            return [str(k) for k in val.keys() if k and not str(k).startswith("_")]
+        if isinstance(val, str) and val:
+            return [val]
+        return []
+
+    # Prefer library helper when present (canonical flat map)
+    try:
+        from . import import_cache as ic
+        rev_map = ic.get_reverse_dependencies(cache) or {}
+        if isinstance(rev_map, dict) and rel in rev_map:
+            got = _as_list(rev_map.get(rel))
+            if got:
+                return got[:80]
+    except Exception:
+        pass
+
+    rev = cache.get("_reverse_dependencies") or {}
+    if not isinstance(rev, dict):
+        return []
+
+    # Direct flat
+    if rel in rev:
+        got = _as_list(rev.get(rel))
+        if got:
+            return got[:80]
+
+    # Nested common containers
+    for nest_key in ("index", "dependents", "map", "by_target", "targets"):
+        nested = rev.get(nest_key)
+        if isinstance(nested, dict) and rel in nested:
+            got = _as_list(nested.get(rel))
+            if got:
+                return got[:80]
+
+    # Fallback: O(E) scan of resolved_pairs
+    found: List[str] = []
+    for src, data in cache.items():
+        if not isinstance(src, str) or src.startswith("_") or not isinstance(data, dict):
+            continue
+        for p in data.get("resolved_pairs") or []:
+            if not isinstance(p, dict):
+                continue
+            tgt = p.get("resolved_path") or p.get("resolved") or ""
+            if tgt == rel or str(tgt).endswith("/" + rel) or str(tgt).endswith(rel):
+                if src not in found:
+                    found.append(src)
+    return found[:80]
+
+
 def _root(project_root: Optional[Union[str, Path]] = None) -> Path:
     if project_root:
         try:
@@ -327,17 +437,7 @@ def prepare_edit(
             })
         out["dependencies"] = deps[:80]
         out["low_conf_edges"] = low
-        # reverse deps
-        rev = cache.get("_reverse_dependencies") or {}
-        if isinstance(rev, dict):
-            # may be {file: [importers]} or nested
-            importers = rev.get(rel)
-            if importers is None and isinstance(rev.get("index"), dict):
-                importers = rev["index"].get(rel)
-            if isinstance(importers, list):
-                out["dependents"] = importers[:80]
-            elif isinstance(importers, dict):
-                out["dependents"] = list(importers.keys())[:80]
+        out["dependents"] = resolve_dependents_from_cache(cache, rel)
         cycles = cache.get("_cycles") or {}
         all_cyc = set(cycles.get("all_cycle_files") or [])
         out["in_cycle"] = rel in all_cyc
@@ -363,20 +463,10 @@ def session_bootstrap(
     out: Dict[str, Any] = {
         "success": True,
         "project_root": str(root),
-        "core_surface": [
-            "session_bootstrap",
-            "check_changes",
-            "prepare_edit",
-            "suggest_next_actions",
-            "record_change",
-            "mark_green",
-        ],
-        "advanced_intel": [
-            "get_cycles",
-            "get_barrel_reports",
-            "get_resolution_diagnostics",
-            "health(format=json)",
-        ],
+        "core_surface": list(CORE_DAILY_NAMES),
+        "core_daily": list(CORE_DAILY_TOOLS),
+        "core_count": len(CORE_DAILY_NAMES),
+        "advanced_intel": list(ADVANCED_INTEL_TOOLS),
     }
     health_sum: Dict[str, Any] = {}
     red_files: List[str] = []

{wikifier-4.6.0 → wikifier-4.6.2}/wikifier/cli.py

@@ -772,6 +772,22 @@ def main():
                 res = why_file(_args[0], project_root=project_root)
                 print(_json.dumps(res, indent=2, default=str))
                 return 0 if res.get("success") else 1
+            if _cmd0 in (
+                "seed-source-hashes",
+                "seed-source-content-hashes",
+                "seed_source_content_hashes",
+                "seed-hashes",
+            ):
+                import json as _json
+                force = any(a in ("--force", "-f") for a in _args)
+                res = seed_source_content_hashes(project_root=project_root, force=force)
+                print(_json.dumps(res, indent=2, default=str))
+                return 0 if res.get("success") else 1
+            if _cmd0 in ("list-core-tools", "list_core_tools", "core-tools"):
+                import json as _json
+                res = list_core_tools()
+                print(_json.dumps(res, indent=2, default=str))
+                return 0 if res.get("success") else 1
             if _cmd0 == "validate":
                 import json as _json
                 if _health_mod is not None:
@@ -1208,48 +1224,34 @@ def check_changes(project_root: Optional[Union[str, Path]] = None) -> Dict[str,
                             if stored_hash and live and stored_hash == live:
                                 verdict = {"content_dirty": False, "reason": "content_unchanged", "seed_baseline": False, "hash": live}
                             elif not stored_hash and live:
-                                verdict = {"content_dirty": False, "reason": "no_baseline", "seed_baseline": True, "hash": live}
+                                # no baseline → dirty (do not seed post-edit hash)
+                                verdict = {"content_dirty": True, "reason": "no_baseline", "seed_baseline": False, "hash": live}
                             elif live and stored_hash and stored_hash != live:
                                 verdict = {"content_dirty": True, "reason": "content_changed", "seed_baseline": False, "hash": live}
                         except Exception:
                             pass
 
-                    if verdict.get("seed_baseline") and verdict.get("hash") and isinstance(ent, dict):
-                        ent["source_content_hash"] = verdict["hash"]
-                        entries[rel] = ent
-                        health_dirty = True
-                        seeded_baselines += 1
-                        # Do not Yellow solely for first baseline seed on mtime thrash
-                        continue
                     if not verdict.get("content_dirty") and verdict.get("reason") == "content_unchanged":
                         skipped_mtime_only += 1
                         continue
-                    # Content changed (or unclassifiable): Yellow with content reason
+                    # Content changed, no baseline, or unclassifiable: Yellow.
+                    # Never write source_content_hash here — only mark_green sets the
+                    # trusted baseline (avoids seeding post-edit bytes and staying Green).
                     reason = (
                         "content changed since last trusted baseline (check_changes content-honest)"
                         if verdict.get("reason") == "content_changed"
                         else "content change or no baseline (check_changes content-honest auto-detect)"
                     )
                     _upsert(root, rel, "🟡 Yellow", reason)
-                    # refresh local entries view after upsert
                     try:
                         health_data = _health_mod.load_health(root)
                         entries = health_data.setdefault("entries", {})
-                        if verdict.get("hash") and rel in entries and isinstance(entries[rel], dict):
-                            # keep prior baseline until mark-green; do not update hash on yellow
-                            pass
                         health_dirty = False  # upsert already saved
                     except Exception:
                         pass
                     _add_to_pending(root, rel, "Content change auto-detected — review and run mark-green after wiki update")
                     _ensure_journal_entry(root, "auto-detected", rel, reason)
                     changed_count += 1
-                if health_dirty and health_data is not None:
-                    try:
-                        if hasattr(_health_mod, "save_health"):
-                            _health_mod.save_health(root, health_data)
-                    except Exception:
-                        pass
                 # Keep pending queue aligned with lean monitored_paths (no flood outside scope)
                 if hasattr(_health_mod, "prune_pending_to_monitored"):
                     try:
@@ -1647,6 +1649,27 @@ def why_file(
     return _wf(file, project_root=project_root, max_results=max_results)
 
 
+def seed_source_content_hashes(
+    project_root: Optional[Union[str, Path]] = None,
+    only_green: bool = True,
+    force: bool = False,
+    directory: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Seed source_content_hash baselines without mass Yellow (migration helper)."""
+    root = _get_effective_root(project_root)
+    if _health_mod is None or not hasattr(_health_mod, "seed_source_content_hashes"):
+        return {"success": False, "project_root": str(root), "error": "health.seed_source_content_hashes unavailable"}
+    return _health_mod.seed_source_content_hashes(
+        root, only_green=only_green, force=force, directory=directory
+    )
+
+
+def list_core_tools() -> Dict[str, Any]:
+    """Core daily agent tool listing (prefer over full MCP catalog)."""
+    from .agent_loop import list_core_tools as _lct
+    return _lct()
+
+
 def update_maps(
     project_root: Optional[Union[str, Path]] = None,
     full: bool = False,

{wikifier-4.6.0 → wikifier-4.6.2}/wikifier/health.py

@@ -272,12 +272,16 @@ def classify_content_dirty(
             "seed_baseline": False,
         }
     if not stored_hash:
+        # No trusted baseline (legacy Green / never mark-green): when this path is
+        # under check_changes dirty observation, treat as needing attention so a
+        # post-edit rewrite cannot silently re-seed the *new* bytes and stay Green.
+        # Callers that only want to migrate baselines should use an explicit seed helper.
         return {
-            "content_dirty": False,
+            "content_dirty": True,
             "missing": False,
             "hash": live,
             "reason": "no_baseline",
-            "seed_baseline": True,
+            "seed_baseline": False,
         }
     if stored_hash == live:
         return {
@@ -296,6 +300,89 @@ def classify_content_dirty(
     }
 
 
+def seed_source_content_hashes(
+    root: "str | Path",
+    *,
+    only_green: bool = True,
+    force: bool = False,
+    directory: Optional[str] = None,
+    max_files: int = 50000,
+) -> Dict[str, Any]:
+    """Seed trusted ``source_content_hash`` for existing health entries without Yellow thrash.
+
+    Migration helper for post-4.6.x content-honest dirty: legacy 🟢 entries without a
+    baseline get the *current on-disk* hash recorded so subsequent mtime-only touches
+    do not Yellow. Status/reason are left unchanged (no mass auto-Yellow).
+
+    Args:
+        only_green: if True, only seed entries whose status is Green.
+        force: if True, re-hash even when a baseline already exists.
+        directory: optional path prefix filter.
+        max_files: safety cap.
+
+    Returns structured stats (seeded, skipped_*, missing_on_disk, errors sample).
+    """
+    root = Path(root).resolve()
+    result: Dict[str, Any] = {
+        "success": True,
+        "project_root": str(root),
+        "seeded": 0,
+        "skipped_has_hash": 0,
+        "skipped_not_green": 0,
+        "skipped_missing": 0,
+        "skipped_filter": 0,
+        "errors": [],
+        "sample_seeded": [],
+    }
+    try:
+        data = load_health(root)
+        entries = data.setdefault("entries", {})
+        dirty = False
+        dir_pref = (directory or "").rstrip("/")
+        for rel, ent in list(entries.items()):
+            if not isinstance(ent, dict):
+                continue
+            if dir_pref and not (str(rel) == dir_pref or str(rel).startswith(dir_pref + "/")):
+                result["skipped_filter"] += 1
+                continue
+            st = str(ent.get("status") or "")
+            if only_green and "Green" not in st and "🟢" not in st:
+                result["skipped_not_green"] += 1
+                continue
+            if ent.get("source_content_hash") and not force:
+                result["skipped_has_hash"] += 1
+                continue
+            src = root / rel
+            if not src.is_file():
+                result["skipped_missing"] += 1
+                continue
+            h = compute_source_content_hash(src)
+            if not h:
+                result["skipped_missing"] += 1
+                continue
+            ent["source_content_hash"] = h
+            # Do not change status/reason — migration only
+            entries[rel] = ent
+            dirty = True
+            result["seeded"] += 1
+            if len(result["sample_seeded"]) < 8:
+                result["sample_seeded"].append(rel)
+            if result["seeded"] >= max_files:
+                break
+        if dirty:
+            save_health(root, data)
+        result["message"] = (
+            f"Seeded {result['seeded']} source_content_hash baseline(s) "
+            f"(skipped has_hash={result['skipped_has_hash']}, "
+            f"not_green={result['skipped_not_green']}, missing={result['skipped_missing']})."
+        )
+    except Exception as e:
+        result["success"] = False
+        result["error"] = str(e)
+        result["errors"].append(str(e))
+    return result
+
+
 def _is_stale_wiki(root: Path, file: str, entry: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     """
     Core durable stale wiki detector (B3).

{wikifier-4.6.0 → wikifier-4.6.2}/wikifier/mcp/server.py

@@ -526,6 +526,32 @@ def why_file(
         return {"success": False, "file": file, "project_root": str(root), "error": str(e)}
 
 
+@mcp.tool()
+def seed_source_content_hashes(
+    project_root: Optional[str] = None,
+    only_green: bool = True,
+    force: bool = False,
+    directory: Optional[str] = None,
+) -> dict:
+    """Seed source_content_hash for Green entries without mass Yellow thrash (migration)."""
+    root = _get_effective_root(project_root)
+    try:
+        from wikifier.cli import seed_source_content_hashes as _lib_seed
+        return _lib_seed(project_root=root, only_green=only_green, force=force, directory=directory)
+    except Exception as e:
+        return {"success": False, "project_root": str(root), "error": str(e)}
+
+
+@mcp.tool()
+def list_core_tools() -> dict:
+    """List Core daily agent tools vs advanced intel (prefer Core every session)."""
+    try:
+        from wikifier.cli import list_core_tools as _lib_lct
+        return _lib_lct()
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
 @mcp.tool()
 def update_maps(
     project_root: Optional[str] = None,

{wikifier-4.6.0 → wikifier-4.6.2/wikifier.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wikifier
-Version: 4.6.0
+Version: 4.6.2
 Summary: Zero-dependency agent-to-agent codebase wiki for LLMs and AI agents. Autonomously maintained via record-change and mark-green for token-efficient lookup of files, dependencies, health, and summaries — across tiny scripts to 50k+ monorepos. Optional MCP server with rich tools for agents.
 Author-email: Aron Amos <aron@example.com>
 Maintainer: Aron Amos