pantheon-opencode 1.3.7 → 1.4.1

package/README.md

@@ -2,7 +2,7 @@
 <h1 align="center">Pantheon</h1>
 
 <p align="center">
-  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-v1.3.6--beta-blue" alt="Version"></a>
+  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-v1.4.1--candidate-blue" alt="Version"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="License"></a>
   <a href="docs/agents/README.md"><img src="https://img.shields.io/badge/agents-14-purple" alt="Agents"></a>
   <a href="src/skills/README.md"><img src="https://img.shields.io/badge/skills-21-orange" alt="Skills"></a>
@@ -239,17 +239,16 @@ Fail-open: if the child session messages are unavailable (or empty), the read
 returns the report exactly as before — the activity sampling never breaks the
 delegation read.
 
-**Completion visibility — no chat injection.** User policy: ZERO delegation
-notifications in the chat transcript — no `<task-notification>` block is ever
-injected into a `chat.message` output (the old queue + flush channel was
-removed). When a job reaches a terminal state (completion observed via
-`session.idle`/`session.error` on the child, or the timeout finalize path), the
-plugin writes a file-only audit log line (echo opt-in via `PANTHEON_HOOKS_LOG`).
-Completion visibility lives in the legitimate channels: the board `[unread]`
-marker (`pantheon_delegation_list`), `pantheon_delegation_read`, TUI toasts
-(pantheon-hooks, `PANTHEON_TOASTS` gate) and compaction carry-forward. Reconcile
-is an acknowledgment, not a completion — it never re-fires the terminal
-transition.
+**Completion visibility — zero chat noise.** Delegation notifications are never
+injected into the chat transcript: neither `chat.message` nor any other chat
+hook or transcript marker is used as a delivery channel. When a job reaches a
+terminal state (completion observed via `session.idle`/`session.error` on the
+child, or the timeout finalize path), the plugin writes a file-only audit log
+line (echo opt-in via `PANTHEON_HOOKS_LOG`). Completion visibility lives in the
+legitimate channels: the board `[unread]` marker
+(`pantheon_delegation_list`), `pantheon_delegation_read`, TUI toasts
+(`PANTHEON_TOASTS` gate), and compaction carry-forward. Reconcile is an
+acknowledgment, not a completion — it never re-fires the terminal transition.
 
 **Timeout:** `background_delegation.timeout_ms` (default `900000` = 15 min). A job
 that has not reached a terminal state is finalized as `error`/`timedOut`.
@@ -338,10 +337,9 @@ logged warn and pass-through.
 
 **Post-compaction state re-assertion (1.3.4):** on `session.compacted`, fresh
 state — running/unread delegations from the board + active goals, capped at 10
-lines — is re-injected as a `<system-reminder>` into the session's next
-message via the shared chat-reminder buffer (`chat-reminders.ts`, the same P0
-messageID guard that protects subagent fires). A session with nothing to
-assert is a silent skip.
+lines — remains available through compaction carry-forward and the board
+(`pantheon_delegation_list` / `pantheon_delegation_read`). A session with
+nothing to assert is a silent skip; no chat transcript injection is performed.
 
 **Preemptive compaction check (1.3.4):** a pure threshold core
 (`preemptive-compact.ts`) warns the model before the context fills: at 78%
@@ -350,36 +348,22 @@ dormant / ready-to-wire — opencode 1.18.x exposes no runtime context-usage
 percentage, so nothing observes it yet; when a source appears, the caller
 wires it in (the enqueue callback is injected).
 
-**Model API-key validation (1.3.4):** `pantheon_delegate` gates the resolved
-child model's provider before dispatching (single source of truth:
-`routing.yml` preset definitions' `apiKeyEnv` — the same check `applyPreset`
-enforces at startup). If an **auto-resolved** model (`options.agentModels` or
-the active preset) points to a provider that requires an API key
-(`apiKeyEnv`) and the env var is unset, the delegate falls back to
-`opencode-go/deepseek-v4-flash` (validated the same way). If the fallback is
-also unusable, the tool returns a clear error **text** (never throws) naming
-the missing env var — and registers **no job** on the board. An **explicit**
-`model` passed by the caller is always respected (warned, not overridden).
-Setting `PANTHEON_MODEL_PRESET` to a preset whose providers have keys, or
-filling the required `PANTHEON_*_API_KEY` env var for the preset's provider,
-resolves the fallback path. If nothing resolves at all (no model, no preset),
-the child keeps using opencode's default model (warned).
-
-**agentModels wiring (1.3.4):** the delegate now also resolves the child model
-via `routing.yml` — `loadRoutingAgentModels` extracts the per-agent models of
-the FIRST-listed preset (the static default, `go-deepseek` today) and passes
-them as `options.agentModels`, branch (b) of the resolve precedence: explicit
-`model` > `options.agentModels` > active preset > opencode default. Delegation
-no longer depends exclusively on the active preset — a delegated child gets a
-sane per-agent model even when no preset is active. Fail-open: a missing or
-unparseable routing.yml yields `{}` (previous behavior, warned).
+**Model selection (1.4.1):** the child session inherits the parent session's
+model through OpenCode. A model override is supplied only when the active
+routing profile defines one; no model API-key validation is performed here.
+
+**agentModels wiring (1.3.4):** `loadRoutingAgentModels` extracts only the
+per-agent models from the explicitly active routing profile and passes them as
+`options.agentModels`. No active profile, missing profile entry, or profile
+without `model` produces an empty map; there is no implicit first-preset or
+DeepSeek fallback. A missing or unparseable `routing.yml` is fail-open and
+omits the child model.
 
 **Delegation log hygiene (1.3.4):** `delegations.log` now records the real
 `task_id` (omitted when empty, never `""`) and a **numeric** `duration_ms`
-(null when unset) so downstream aggregation works. The idle-flush log entry is
-deduplicated: the flush logs a summary (count + aggregated line count) and the
-reminder content is logged exactly once, at `chat.message` delivery — no more
-duplicate lines for the same notification.
+(null when unset) so downstream aggregation works. Terminal events are
+file-only audit entries; completion is surfaced by TUI toast (when enabled),
+the board, and the list/read tools — never by chat delivery.
 
 **Env vars & config:**
 
@@ -1040,11 +1024,17 @@ Use the isolated sandbox (`~/pantheon-sandbox/`) — **never** the dev environme
 
 **Happy path (clean edit):** any normal tool call (exit 0) is **silent** — no console output by design, even though the audit hooks append their log files (`sessions.log`, `delegations.log`). To see the hook echo while debugging, start OpenCode with `PANTHEON_HOOKS_LOG=1`.
 
-**Delegation path (chat.message reminders):** on OpenCode 1.18.13 the TUI drops `tui.toast.show` events, so delegation signals are injected into the next user message as a single `<system-reminder>` text part (oh-my-openagent fallback pattern). Ask something that dispatches subagents (e.g. *"dispare 2 subagentes apollo em paralelo para listar arquivos e comparar resultados"*) and expect:
+**Delegation path (zero chat noise):** delegation signals are surfaced through
+TUI toasts (when enabled), the board's `[unread]` marker, and the
+`pantheon_delegation_list` / `pantheon_delegation_read` tools. Ask something
+that dispatches subagents (e.g. *"dispare 2 subagentes apollo em paralelo para
+listar arquivos e comparar resultados"*) and expect:
 
-- A `<system-reminder>` in the chat with `🚀 apollo em execução` / `✅ apollo concluiu` (or the aggregate `✅ N agentes concluídos (...)` for 3+ agents completing within 6s)
+- A TUI toast with `🚀 apollo em execução` / `✅ apollo concluiu` when
+  `PANTHEON_TOASTS` permits it
+- `[unread]` in `pantheon_delegation_list` until the terminal result is read
 - An honest append to `logs/agent-sessions/delegations.log`: the **real agent name** (extracted from `tool_input.subagent_type`, never `unknown` when present) and a **non-fabricated status** — `success` only on explicit completion evidence, `failure` for refusals/errors, `unknown` otherwise
-- With `export PANTHEON_TOASTS=off` before starting OpenCode: no toasts/reminders at all
+- With `export PANTHEON_TOASTS=off` before starting OpenCode: no toasts; board/list/read and audit-log visibility remain available
 
 ### Pre-commit hooks (local secret gate)
 

package/opencode.json

@@ -14,8 +14,6 @@
   "experimental": {
     "subagent_depth": 2
   },
-  "model": "opencode-go/deepseek-v4-flash",
-  "small_model": "opencode-go/deepseek-v4-flash",
   "permission": {
     "skill": {
       "*": "allow"
@@ -27,7 +25,8 @@
       "npx *": "allow",
       "pytest *": "allow",
       "ruff *": "allow",
-      "pip *": "allow"
+      "pip *": "allow",
+      "python3 *": "allow"
     }
   },
   "mcp": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pantheon-opencode",
-  "version": "1.3.7",
+  "version": "1.4.1",
   "description": "Multi-agent orchestration for OpenCode — 14 specialized agents, TDD, Themis review gates.",
   "publishConfig": {
     "access": "public",

package/scripts/install/opencode.mjs

@@ -450,6 +450,7 @@ export async function installOpenCode(
       'memory_mcp_server.py',
       'scrub-secrets.py',
       '_pantheon_paths.py',
+      'mcp_codemap_module.py',
       'mcp_persistence_server.py',
       'pantheon_vision_server.py',
       'eval_store.py',
@@ -465,6 +466,7 @@ export async function installOpenCode(
       'code_mode_server.py': join(ROOT, 'src', 'mcp', 'code_mode_server.py'),
       'memory_mcp_server.py': join(ROOT, 'src', 'mcp', 'memory_mcp_server.py'),
       '_pantheon_paths.py': join(ROOT, 'src', 'mcp', '_pantheon_paths.py'),
+      'mcp_codemap_module.py': join(ROOT, 'src', 'mcp', 'mcp_codemap_module.py'),
       'mcp_persistence_server.py': join(ROOT, 'src', 'mcp', 'mcp_persistence_server.py'),
       'pantheon_vision_server.py': join(ROOT, 'src', 'mcp', 'pantheon_vision_server.py'),
       'eval_store.py': join(ROOT, 'src', 'mcp', 'eval_store.py'),

package/src/mcp/mcp_codemap_module.py

@@ -0,0 +1,185 @@
+# ruff: noqa: E701,E702,E741,I001,E401,RUF100,W292
+"""Pantheon Codemap — lean KG for Python/TS (ast+regex), 3 tables+FTS5."""
+from __future__ import annotations
+import ast, hashlib, re, sqlite3
+from pathlib import Path
+from typing import Any
+LARGE_FILE_THRESHOLD = 512 * 1024
+SUPPORTED_EXTS: dict[str, str] = {".py":"python",".ts":"typescript",".tsx":"typescript",".js":"typescript",".jsx":"typescript",".mts":"typescript",".cts":"typescript"}
+CODEMAP_SCHEMA_SQL = """
+CREATE TABLE IF NOT EXISTS code_entities (id TEXT PRIMARY KEY,file_path TEXT NOT NULL,name TEXT NOT NULL,type TEXT NOT NULL,language TEXT NOT NULL,start_line INTEGER,end_line INTEGER,signature TEXT,docstring TEXT);
+CREATE INDEX IF NOT EXISTS idx_code_entities_type ON code_entities(type);
+CREATE INDEX IF NOT EXISTS idx_code_entities_name ON code_entities(name);
+CREATE INDEX IF NOT EXISTS idx_code_entities_path ON code_entities(file_path);
+CREATE TABLE IF NOT EXISTS code_relations (id INTEGER PRIMARY KEY AUTOINCREMENT,source_id TEXT NOT NULL,target_id TEXT NOT NULL,type TEXT NOT NULL,FOREIGN KEY(source_id) REFERENCES code_entities(id),FOREIGN KEY(target_id) REFERENCES code_entities(id));
+CREATE INDEX IF NOT EXISTS idx_code_relations_source ON code_relations(source_id);
+CREATE INDEX IF NOT EXISTS idx_code_relations_target ON code_relations(target_id);
+CREATE TABLE IF NOT EXISTS code_files (path TEXT PRIMARY KEY,hash TEXT NOT NULL,language TEXT NOT NULL,indexed_at TEXT NOT NULL DEFAULT (datetime('now')));
+CREATE VIRTUAL TABLE IF NOT EXISTS code_entities_fts USING fts5(name,signature,docstring,content='code_entities',content_rowid='rowid',tokenize='porter unicode61');
+CREATE TRIGGER IF NOT EXISTS code_entities_ai AFTER INSERT ON code_entities BEGIN INSERT INTO code_entities_fts(rowid,name,signature,docstring) VALUES (new.rowid,new.name,new.signature,new.docstring); END;
+CREATE TRIGGER IF NOT EXISTS code_entities_ad AFTER DELETE ON code_entities BEGIN INSERT INTO code_entities_fts(code_entities_fts,rowid,name,signature,docstring) VALUES ('delete',old.rowid,old.name,old.signature,old.docstring); END;
+CREATE TRIGGER IF NOT EXISTS code_entities_au AFTER UPDATE ON code_entities BEGIN INSERT INTO code_entities_fts(code_entities_fts,rowid,name,signature,docstring) VALUES ('delete',old.rowid,old.name,old.signature,old.docstring); INSERT INTO code_entities_fts(rowid,name,signature,docstring) VALUES (new.rowid,new.name,new.signature,new.docstring); END;
+"""
+def ensure_codemap_schema(conn: sqlite3.Connection) -> None:
+    conn.executescript(CODEMAP_SCHEMA_SQL); conn.commit()
+def drop_codemap_schema(conn: sqlite3.Connection) -> None:
+    conn.executescript("DROP TRIGGER IF EXISTS code_entities_ai;DROP TRIGGER IF EXISTS code_entities_ad;DROP TRIGGER IF EXISTS code_entities_au;DROP TABLE IF EXISTS code_entities_fts;DROP TABLE IF EXISTS code_relations;DROP TABLE IF EXISTS code_entities;DROP TABLE IF EXISTS code_files;"); conn.commit()
+def _hash_content(c: str) -> str: return hashlib.sha256(c.encode()).hexdigest()
+def _entity_id(fp: str, name: str, tp: str) -> str: return hashlib.sha256(f"{fp}:{name}:{tp}".encode()).hexdigest()[:16]
+def _parse_python_entities(fp: str, content: str) -> tuple[list[dict[str,Any]], list[dict[str,Any]]]:  # noqa: C901, PLR0912, PLR0915
+    ents: list[dict[str,Any]] = []; rels: list[dict[str,Any]] = []; ph: dict[str,dict[str,Any]] = {}
+    try: tree = ast.parse(content, filename=fp)
+    except SyntaxError: return [], []
+    file_mod: str|None = None
+    def _file_mod() -> str:
+        nonlocal file_mod
+        if file_mod is None:
+            stem = Path(fp).stem; fid=_entity_id(fp,stem,"module")
+            if fid not in ph: ph[fid]={"id":fid,"file_path":fp,"name":stem,"type":"module","language":"python","start_line":1,"end_line":1,"signature":f"module {stem}","docstring":""}
+            file_mod=fid
+        return file_mod
+    for node in tree.body:
+        if isinstance(node, ast.ClassDef):
+            cid=_entity_id(fp,node.name,"class"); doc=ast.get_docstring(node) or ""
+            bases=[]
+            for b in node.bases:
+                if isinstance(b, ast.Name): bases.append(b.id)
+                elif isinstance(b, ast.Attribute): bases.append(b.attr)
+            sig=f"class {node.name}({', '.join(bases)})" if bases else f"class {node.name}"
+            ents.append({"id":cid,"file_path":fp,"name":node.name,"type":"class","language":"python","start_line":getattr(node,"lineno",0),"end_line":getattr(node,"end_lineno",0) or getattr(node,"lineno",0),"signature":sig,"docstring":doc})
+            for base in bases:
+                tid=_entity_id(f"external:{base}",base,"class")
+                if tid not in ph: ph[tid]={"id":tid,"file_path":f"external:{base}","name":base,"type":"class","language":"python","start_line":0,"end_line":0,"signature":f"class {base}","docstring":""}
+                rels.append({"source_id":cid,"target_id":tid,"type":"inherits"})
+            for item in node.body:
+                if isinstance(item,(ast.FunctionDef,ast.AsyncFunctionDef)):
+                    mid=_entity_id(fp,f"{node.name}.{item.name}","method"); docm=ast.get_docstring(item) or ""; args=", ".join(a.arg for a in item.args.args); sig_m=f"def {item.name}({args})"
+                    ents.append({"id":mid,"file_path":fp,"name":f"{node.name}.{item.name}","type":"method","language":"python","start_line":getattr(item,"lineno",0),"end_line":getattr(item,"end_lineno",0) or getattr(item,"lineno",0),"signature":sig_m,"docstring":docm})
+        elif isinstance(node,(ast.FunctionDef,ast.AsyncFunctionDef)):
+            fid=_entity_id(fp,node.name,"function"); doc=ast.get_docstring(node) or ""; args=", ".join(a.arg for a in node.args.args); sig=f"def {node.name}({args})"
+            ents.append({"id":fid,"file_path":fp,"name":node.name,"type":"function","language":"python","start_line":getattr(node,"lineno",0),"end_line":getattr(node,"end_lineno",0) or getattr(node,"lineno",0),"signature":sig,"docstring":doc})
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                mod=alias.name.split(".")[0]; tid=_entity_id(f"external:{mod}",mod,"module")
+                if tid not in ph: ph[tid]={"id":tid,"file_path":f"external:{mod}","name":mod,"type":"module","language":"python","start_line":0,"end_line":0,"signature":f"import {mod}","docstring":""}
+                src=_file_mod(); rels.append({"source_id":src,"target_id":tid,"type":"imports"})
+        elif isinstance(node, ast.ImportFrom):
+            mod=(node.module or "").split(".")[0]
+            if mod:
+                tid=_entity_id(f"external:{mod}",mod,"module")
+                if tid not in ph: ph[tid]={"id":tid,"file_path":f"external:{mod}","name":mod,"type":"module","language":"python","start_line":0,"end_line":0,"signature":f"from {mod} import ...","docstring":""}
+                src=_file_mod(); rels.append({"source_id":src,"target_id":tid,"type":"imports"})
+    eids={e["id"] for e in ents}
+    for pid,pent in ph.items():
+        if pid not in eids: ents.append(pent)
+    return ents, rels
+_TS_CLASS_RE=re.compile(r"^\s*(?:export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?",re.MULTILINE)
+_TS_INTERFACE_RE=re.compile(r"^\s*(?:export\s+)?interface\s+(\w+)",re.MULTILINE)
+_TS_FUNC_RE=re.compile(r"^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(",re.MULTILINE)
+_TS_CONST_RE=re.compile(r"^\s*(?:export\s+)?const\s+(\w+)\s*(?:[:=])",re.MULTILINE)
+_TS_IMPORT_RE=re.compile(r"^\s*import\s+.*?from\s+['\"]([^'\"]+)['\"]",re.MULTILINE)
+def _parse_typescript_entities(fp: str, content: str) -> tuple[list[dict[str,Any]], list[dict[str,Any]]]:  # noqa: C901
+    ents: list[dict[str,Any]]=[]; rels: list[dict[str,Any]]=[]; ph: dict[str,dict[str,Any]]={}
+    def _ph(name: str, tp: str, sig: str) -> str:
+        tid=_entity_id(f"external:{name}",name,tp)
+        if tid not in ph: ph[tid]={"id":tid,"file_path":f"external:{name}","name":name,"type":tp,"language":"typescript","start_line":0,"end_line":0,"signature":sig,"docstring":""}
+        return tid
+    lines=content.splitlines()
+    def _line(pat: str, name: str) -> int:
+        for i,l in enumerate(lines, start=1):
+            if pat in l and name in l: return i
+        return 1
+    for m in _TS_CLASS_RE.finditer(content):
+        name=m.group(1); base=m.group(2); cid=_entity_id(fp,name,"class"); sig=f"class {name}"+(f" extends {base}" if base else "")
+        ents.append({"id":cid,"file_path":fp,"name":name,"type":"class","language":"typescript","start_line":_line("class",name),"end_line":_line("class",name),"signature":sig,"docstring":""})
+        if base: tid=_ph(base,"class",f"class {base}"); rels.append({"source_id":cid,"target_id":tid,"type":"inherits"})
+    for m in _TS_INTERFACE_RE.finditer(content):
+        name=m.group(1); iid=_entity_id(fp,name,"interface")
+        ents.append({"id":iid,"file_path":fp,"name":name,"type":"interface","language":"typescript","start_line":_line("interface",name),"end_line":_line("interface",name),"signature":f"interface {name}","docstring":""})
+    for m in _TS_FUNC_RE.finditer(content):
+        name=m.group(1); fid=_entity_id(fp,name,"function")
+        ents.append({"id":fid,"file_path":fp,"name":name,"type":"function","language":"typescript","start_line":_line("function",name),"end_line":_line("function",name),"signature":f"function {name}()","docstring":""})
+    for m in _TS_CONST_RE.finditer(content):
+        name=m.group(1); cid=_entity_id(fp,name,"const")
+        ents.append({"id":cid,"file_path":fp,"name":name,"type":"const","language":"typescript","start_line":_line("const",name),"end_line":_line("const",name),"signature":f"const {name}","docstring":""})
+    for m in _TS_IMPORT_RE.finditer(content):
+        raw=m.group(1); mod=raw.split("/")[-1].replace(".js","").replace(".ts","") or raw; tid=_ph(mod,"module",f"import {raw}"); stem=Path(fp).stem; src=_entity_id(fp,stem,"module")
+        if src not in {e["id"] for e in ents} and src not in ph: ph[src]={"id":src,"file_path":fp,"name":stem,"type":"module","language":"typescript","start_line":1,"end_line":1,"signature":f"module {stem}","docstring":""}
+        rels.append({"source_id":src,"target_id":tid,"type":"imports"})
+    eids={e["id"] for e in ents}
+    for pid,pent in ph.items():
+        if pid not in eids: ents.append(pent)
+    return ents, rels
+def _insert_entities_and_relations(conn: sqlite3.Connection, ents: list[dict[str,Any]], rels: list[dict[str,Any]]) -> None:
+    for e in ents:
+        conn.execute("INSERT OR REPLACE INTO code_entities (id,file_path,name,type,language,start_line,end_line,signature,docstring) VALUES (?,?,?,?,?,?,?,?,?)",[e["id"],e["file_path"],e["name"],e["type"],e["language"],e["start_line"],e["end_line"],e["signature"],e["docstring"]])
+    for r in rels:
+        if not conn.execute("SELECT 1 FROM code_relations WHERE source_id=? AND target_id=? AND type=?", [r["source_id"],r["target_id"],r["type"]]).fetchone():
+            conn.execute("INSERT INTO code_relations (source_id,target_id,type) VALUES (?,?,?)", [r["source_id"],r["target_id"],r["type"]])
+def code_index(conn: sqlite3.Connection, path: str|Path|None=None, force: bool=False) -> dict[str,Any]:  # noqa: C901, PLR0912, PLR0915
+    ensure_codemap_schema(conn)
+    base=Path(path) if path else Path.cwd()
+    if not base.exists(): return {"error":f"Path not found: {base}","indexed":0,"skipped":0}
+    files: list[Path]=[base] if base.is_file() else [p for ext in SUPPORTED_EXTS for p in base.rglob(f"*{ext}")]
+    indexed=skipped=errors=large_skipped=unsupported=0
+    for f in files:
+        if any(p.startswith(".") for p in f.parts) and ".pantheon" not in str(f) and (".git" in f.parts or "__pycache__" in f.parts): continue
+        if "node_modules" in f.parts or ".venv" in f.parts or "venv" in f.parts: continue
+        ext=f.suffix.lower(); lang=SUPPORTED_EXTS.get(ext)
+        if not lang: unsupported+=1; continue
+        try:
+            if f.stat().st_size > LARGE_FILE_THRESHOLD: large_skipped+=1; continue
+            content=f.read_text(encoding="utf-8",errors="ignore")
+            if not content.strip():
+                h=_hash_content(content); conn.execute("INSERT OR REPLACE INTO code_files (path,hash,language) VALUES (?,?,?)",[str(f),h,lang]); conn.commit(); skipped+=1; continue
+            h=_hash_content(content)
+            row=conn.execute("SELECT hash FROM code_files WHERE path=?",[str(f)]).fetchone()
+            if row and row[0]==h and not force: skipped+=1; continue
+            ents,rels=_parse_python_entities(str(f),content) if lang=="python" else _parse_typescript_entities(str(f),content)
+            if not ents and not rels:
+                conn.execute("INSERT OR REPLACE INTO code_files (path,hash,language) VALUES (?,?,?)",[str(f),h,lang]); conn.commit()
+                try: ast.parse(content)
+                except SyntaxError: errors+=1; continue
+                skipped+=1; continue
+            _insert_entities_and_relations(conn,ents,rels)
+            conn.execute("INSERT OR REPLACE INTO code_files (path,hash,language) VALUES (?,?,?)",[str(f),h,lang]); conn.commit(); indexed+=1
+        except Exception: errors+=1; continue
+    return {"indexed":indexed,"skipped":skipped,"errors":errors,"large_skipped":large_skipped,"unsupported":unsupported}
+def code_query(conn: sqlite3.Connection, query: str, type_filter: str|None=None, limit: int=10) -> list[dict[str,Any]]:
+    if not query or not query.strip(): return []
+    limit=max(1,min(50,int(limit))); q=query.strip(); ensure_codemap_schema(conn)
+    try:
+        fts_q=" OR ".join(f'"{w}"*' for w in q.split() if w)
+        if not fts_q: raise ValueError
+        if type_filter:
+            rows=conn.execute("SELECT e.id,e.file_path,e.name,e.type,e.language,e.start_line,e.end_line,e.signature,e.docstring FROM code_entities_fts f JOIN code_entities e ON e.rowid=f.rowid WHERE code_entities_fts MATCH ? AND e.type=? ORDER BY rank LIMIT ?",[fts_q,type_filter,limit]).fetchall()
+        else:
+            rows=conn.execute("SELECT e.id,e.file_path,e.name,e.type,e.language,e.start_line,e.end_line,e.signature,e.docstring FROM code_entities_fts f JOIN code_entities e ON e.rowid=f.rowid WHERE code_entities_fts MATCH ? ORDER BY rank LIMIT ?",[fts_q,limit]).fetchall()
+        if rows: return [dict(r) for r in rows]
+    except Exception: pass
+    try:
+        like=f"%{q}%"
+        if type_filter:
+            rows=conn.execute("SELECT id,file_path,name,type,language,start_line,end_line,signature,docstring FROM code_entities WHERE (name LIKE ? OR signature LIKE ? OR docstring LIKE ?) AND type=? LIMIT ?",[like,like,like,type_filter,limit]).fetchall()
+        else:
+            rows=conn.execute("SELECT id,file_path,name,type,language,start_line,end_line,signature,docstring FROM code_entities WHERE name LIKE ? OR signature LIKE ? OR docstring LIKE ? LIMIT ?",[like,like,like,limit]).fetchall()
+        return [dict(r) for r in rows]
+    except Exception: return []
+def code_neighbors(conn: sqlite3.Connection, entity_id: str, depth: int=1) -> dict[str,Any]:
+    ensure_codemap_schema(conn); depth=max(1,min(3,int(depth)))
+    row=conn.execute("SELECT * FROM code_entities WHERE id=?",[entity_id]).fetchone()
+    if not row: return {"error":"Entity not found","entity_id":entity_id}
+    start=dict(row); visited: dict[str,dict[str,Any]]={entity_id:start}; queue=[(entity_id,0)]; edges=[]; seen=set()
+    while queue:
+        cur,d=queue.pop(0)
+        if d>=depth: continue
+        for r in conn.execute("SELECT * FROM code_relations WHERE source_id=? OR target_id=?",[cur,cur]).fetchall():
+            rel=dict(r); key=(rel["source_id"],rel["target_id"],rel["type"])
+            if key in seen: continue
+            seen.add(key); edges.append(rel)
+            nid=rel["target_id"] if rel["source_id"]==cur else rel["source_id"]
+            if nid not in visited:
+                nrow=conn.execute("SELECT * FROM code_entities WHERE id=?",[nid]).fetchone()
+                visited[nid]=dict(nrow) if nrow else {"id":nid,"file_path":"external:unknown","name":nid,"type":"placeholder","language":"","start_line":0,"end_line":0,"signature":"","docstring":""}
+                if d+1<depth: queue.append((nid,d+1))
+    return {"entity":start,"neighbors":[v for k,v in visited.items() if k!=entity_id],"relations":edges,"depth":depth}

package/src/mcp/memory_mcp_server.py

@@ -20,12 +20,13 @@ Usage:
 
 from __future__ import annotations
 
+import contextlib
 import functools
 import json
 import os
 import sqlite3
 import time
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
@@ -34,6 +35,18 @@ from _pantheon_paths import pantheon_home
 from fastembed import TextEmbedding
 from mcp.server.fastmcp import FastMCP
 
+try:
+    import mcp_codemap_module as _codemap
+except ImportError:  # pragma: no cover - deployed runtime may need path fix
+    try:
+        import sys as _sys
+        from pathlib import Path as _Path
+
+        _sys.path.insert(0, str(_Path(__file__).parent))
+        import mcp_codemap_module as _codemap  # type: ignore[no-redef]
+    except ImportError:
+        _codemap = None  # type: ignore[assignment]
+
 # ── Paths ─────────────────────────────────────────────────────────────────────
 
 DB_PATH = pantheon_home() / "memory" / "memory.db"
@@ -128,6 +141,9 @@ def _get_db() -> sqlite3.Connection:
 
     sqlite_vec.load(conn)
     conn.executescript(SCHEMA_SQL)
+    if _codemap is not None:
+        with contextlib.suppress(Exception):
+            _codemap.ensure_codemap_schema(conn)
     return conn
 
 
@@ -198,7 +214,7 @@ def _parse_iso_ts(value: str) -> float:
     """
     dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
     if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=timezone.utc)
+        dt = dt.replace(tzinfo=UTC)
     return dt.timestamp()
 
 
@@ -351,7 +367,7 @@ def memory_store(
     "freshness half-life (2^(-days/decay_days)) so recent entries rank "
     "higher; default None keeps the original rank-only behavior.",
 )
-def memory_search(  # noqa: PLR0912
+def memory_search(  # noqa: C901, PLR0912
     query: str,
     namespace: str | None = None,
     top_k: int = 5,
@@ -675,6 +691,78 @@ def memory_stats() -> dict[str, Any]:
     return stats
 
 
+# ── Codemap Tools ───────────────────────────────────────────────────────────
+
+
+@mcp.tool(
+    description="Index codebase files incrementally (hash-based skip). "
+    "Parses Python (ast) and TypeScript (regex) to build knowledge graph.",
+)
+def code_index(
+    path: str | None = None,
+    force: bool = False,
+) -> dict[str, Any]:
+    """Index code files into knowledge graph.
+
+    Args:
+        path: File or directory to index; None = cwd.
+        force: Re-parse even if hash unchanged.
+
+    Returns:
+        Dict with indexed, skipped, errors, large_skipped, unsupported.
+    """
+    if _codemap is None:
+        return {"error": "codemap module not available"}
+    db = _get_conn()
+    return _codemap.code_index(db, path, force)
+
+
+@mcp.tool(
+    description="Search code entities via FTS5 (with LIKE fallback) and optional type filter.",
+)
+def code_query(
+    query: str,
+    type: str | None = None,
+    limit: int = 10,
+) -> list[dict[str, Any]]:
+    """Search code entities.
+
+    Args:
+        query: Search term (FTS5).
+        type: Optional entity type filter (class, function, method, etc.).
+        limit: Max results (1-50).
+
+    Returns:
+        List of matching entities.
+    """
+    if _codemap is None:
+        return [{"error": "codemap module not available"}]
+    db = _get_conn()
+    return _codemap.code_query(db, query, type, limit)
+
+
+@mcp.tool(
+    description="Get neighbors of a code entity via relations graph (BFS depth 1-3).",
+)
+def code_neighbors(
+    entity_id: str,
+    depth: int = 1,
+) -> dict[str, Any]:
+    """Get graph neighbors for an entity.
+
+    Args:
+        entity_id: Entity ID (hash).
+        depth: BFS depth 1-3.
+
+    Returns:
+        Dict with entity, neighbors, relations or error if not found.
+    """
+    if _codemap is None:
+        return {"error": "codemap module not available"}
+    db = _get_conn()
+    return _codemap.code_neighbors(db, entity_id, depth)
+
+
 # ── Main Entrypoint ───────────────────────────────────────────────────────────
 
 if __name__ == "__main__":

package/src/pantheon/chat-reminders.ts

@@ -1,79 +1,9 @@
 /**
- * Chat Reminders (release-134 Phase 4) — the SHARED <system-reminder> buffer.
+ * Retired transcript-notification module.
  *
- * WHY a shared module (not owned by pantheon-hooks.ts):
- *   1. opencode's legacy plugin loader (verified in the 1.18.16 source,
- *      packages/opencode/src/plugin/index.ts getLegacyPlugins) does
- *      `Object.values(mod)` and treats EVERY export as a plugin factory —
- *      a non-function export throws `TypeError("Plugin export is not a
- *      function")` and a function export is invoked with a PluginInput.
- *      pantheon-hooks.ts therefore cannot EXPORT the enqueue API.
- *   2. src/plugin.ts (a separate plugin file) must ENQUEUE into the SAME
- *      buffer the pantheon-hooks `chat.message` hook drains — a local copy
- *      would enqueue into a buffer that is never delivered.
- *   3. opencode loads plugins via plain `await import(entry)` (PluginLoader),
- *      so both plugin files importing this module resolve to ONE module
- *      instance (Bun/Node module cache) → one shared buffer.
- *
- * release-134 Phase 4 uses this buffer for the post-compaction state
- * re-assertion: `reassertAfterCompaction` (compaction-assert.ts) enqueues a
- * fresh-state block here, and the existing chat.message delivery path
- * (pantheon-hooks.ts) injects it as a <system-reminder> into the session's
- * next message. Zero new delivery code — the P0 messageID guard already
- * protects subagent promptAsync fires.
- *
- * Bounded: at most CHAT_REMINDER_MAX entries, each expiring
- * CHAT_REMINDER_TTL_MS after enqueue. Full-buffer enqueues are SKIPPED,
- * never unbounded. No background timers — expiry is only checked on enqueue
- * and on delivery (drainFreshChatReminders).
+ * Delegation lifecycle state must not be queued for delivery into user
+ * messages. Visibility is provided by the board/list/read tools and TUI
+ * toasts; this intentionally exports no delivery API.
  *
  * @module chat-reminders
  */
-
-/**
- * Hard cap on queued reminder entries (anti-spam philosophy, matching the
- * "throttled signals are skipped, never backlogged" rule).
- */
-export const CHAT_REMINDER_MAX = 10
-
-/** How long a queued reminder stays deliverable (pruned after ~60s). */
-export const CHAT_REMINDER_TTL_MS = 60_000
-
-/** One queued reminder: the text plus its enqueue timestamp. */
-export interface ChatReminderEntry {
-  text: string
-  at: number
-}
-
-/** The shared buffer — module-level state, consumed by the chat.message hook. */
-export const pendingChatReminders: ChatReminderEntry[] = []
-
-/**
- * Queue one chat-reminder entry, pruning expired entries first. Never throws.
- * A full buffer skips the push (bounded, never backlogged).
- */
-export function enqueueChatReminder(text: string): void {
-  const now = Date.now()
-  for (let i = pendingChatReminders.length - 1; i >= 0; i--) {
-    const r = pendingChatReminders[i]
-    if (r !== undefined && now - r.at > CHAT_REMINDER_TTL_MS) pendingChatReminders.splice(i, 1)
-  }
-  if (pendingChatReminders.length >= CHAT_REMINDER_MAX) return
-  pendingChatReminders.push({ text, at: now })
-}
-
-/**
- * Deliver (drain) every FRESH reminder as one joined block: expired entries
- * are dropped, the buffer is cleared in all cases (no leak). Returns
- * undefined when nothing fresh remains — the caller skips injection.
- *
- * This is the delivery helper the pantheon-hooks `chat.message` hook calls
- * AFTER its P0 messageID guard (empty messageID → early return, buffer kept).
- */
-export function drainFreshChatReminders(): string | undefined {
-  const now = Date.now()
-  const fresh = pendingChatReminders.filter((r) => now - r.at <= CHAT_REMINDER_TTL_MS)
-  pendingChatReminders.length = 0
-  if (fresh.length === 0) return undefined
-  return fresh.map((r) => r.text).join('\n')
-}