arkaos 4.22.0 → 4.23.0

package/core/synapse/layers.py

@@ -28,20 +28,20 @@ from typing import Any
 from core.synapse.layers_base import Layer, LayerResult, PromptContext
 
 __all__ = [
-    "Layer",
-    "LayerResult",
-    "PromptContext",
-    "ConstitutionLayer",
-    "DepartmentLayer",
     "AgentLayer",
-    "ProjectLayer",
     "BranchLayer",
     "CommandHintsLayer",
-    "QualityGateLayer",
-    "KnowledgeRetrievalLayer",
+    "ConstitutionLayer",
+    "DepartmentLayer",
     "ForgeContextLayer",
-    "SessionContextLayer",
     "KBContextLayer",
+    "KnowledgeRetrievalLayer",
+    "Layer",
+    "LayerResult",
+    "ProjectLayer",
+    "PromptContext",
+    "QualityGateLayer",
+    "SessionContextLayer",
 ]
 
 
@@ -90,22 +90,75 @@ class ConstitutionLayer(Layer):
 # --- L1: Department Detection ---
 
 DEPARTMENT_PATTERNS: dict[str, str] = {
-    "dev": r"\b(build|code|feature|deploy|test|review|scaffold|debug|refactor|api|migration|stack|implement|fix|bug)\b",
-    "marketing": r"\b(social|content|campaign|post|instagram|linkedin|twitter|tiktok|seo|marketing|ads|email.?campaign|growth|viral)\b",
-    "finance": r"\b(budget|invoice|revenue|forecast|profit|loss|roi|margin|cash.?flow|financial|invest|valuation|pricing)\b",
-    "ecom": r"\b(store|product|shop|shopify|ecommerce|catalog|inventory|cart|checkout|pricing|marketplace)\b",
-    "strategy": r"\b(strategy|brainstorm|market|swot|competitors?|roadmap|pivot|growth|porter|blue.?ocean|positioning)\b",
+    "dev": (
+        r"\b("
+        r"build|code|feature|deploy|test|review|scaffold|"
+        r"debug|refactor|api|migration|stack|implement|fix|"
+        r"bug)\b"
+    ),
+    "marketing": (
+        r"\b("
+        r"social|content|campaign|post|instagram|linkedin|"
+        r"twitter|tiktok|seo|marketing|ads|email.?campaign|"
+        r"growth|viral)\b"
+    ),
+    "finance": (
+        r"\b("
+        r"budget|invoice|revenue|forecast|profit|loss|roi|"
+        r"margin|cash.?flow|financial|invest|valuation|"
+        r"pricing)\b"
+    ),
+    "ecom": (
+        r"\b("
+        r"store|product|shop|shopify|ecommerce|catalog|"
+        r"inventory|cart|checkout|pricing|marketplace)\b"
+    ),
+    "strategy": (
+        r"\b("
+        r"strategy|brainstorm|market|swot|competitors?|"
+        r"roadmap|pivot|growth|porter|blue.?ocean|"
+        r"positioning)\b"
+    ),
     "ops": r"\b(task|automate|meeting|workflow|process|schedule|sop|integration|zapier|n8n)\b",
     "kb": r"\b(learn|persona|knowledge|youtube|transcribe|article|research|zettelkasten|note)\b",
-    "brand": r"\b(brand|logo|colors|palette|mockup|photoshoot|brand.?identity|brand.?guide|mood.?board|naming|visual.?design|motion|ux|ui|wireframe)\b",
+    "brand": (
+        r"\b("
+        r"brand|logo|colors|palette|mockup|photoshoot|brand.?identity|"
+        r"brand.?guide|mood.?board|naming|visual.?design|motion|ux|ui|"
+        r"wireframe)\b"
+    ),
     "saas": r"\b(saas|micro.?saas|plg|freemium|churn|mrr|arr|subscription|onboarding|metrics)\b",
-    "landing": r"\b(landing|funnel|copy|headline|offer|launch|affiliate|webinar|conversion|sales.?page)\b",
-    "community": r"\b(community|group|membership|discord|telegram|skool|circle|gamification|engagement)\b",
+    "landing": (
+        r"\b("
+        r"landing|funnel|copy|headline|offer|launch|"
+        r"affiliate|webinar|conversion|sales.?page)\b"
+    ),
+    "community": (
+        r"\b("
+        r"community|group|membership|discord|"
+        r"telegram|skool|circle|gamification|"
+        r"engagement)\b"
+    ),
     "content": r"\b(viral|hook|script|repurpose|youtube|tiktok|reels|shorts|newsletter|creator)\b",
     "pm": r"\b(sprint|backlog|standup|retro|scrum|kanban|story|estimate|roadmap|agile)\b",
-    "lead": r"\b(leadership|delegation|1on1|feedback|culture|hiring|performance.?review|team.?build)\b",
-    "sales": r"\b(pipeline|proposal|discovery.?call|objection|negotiate|deal|close|prospect|spin|challenger|cold.?email|outreach)\b",
-    "org": r"\b(org.?design|hiring.?plan|onboarding|remote|meeting.?optimize|compensation|decision.?framework)\b",
+    "lead": (
+        r"\b("
+        r"leadership|delegation|1on1|feedback|"
+        r"culture|hiring|performance.?review|"
+        r"team.?build)\b"
+    ),
+    "sales": (
+        r"\b("
+        r"pipeline|proposal|discovery.?call|objection|negotiate|"
+        r"deal|close|prospect|spin|challenger|cold.?email|"
+        r"outreach)\b"
+    ),
+    "org": (
+        r"\b("
+        r"org.?design|hiring.?plan|onboarding|remote|"
+        r"meeting.?optimize|compensation|"
+        r"decision.?framework)\b"
+    ),
 }
 
 
@@ -317,10 +370,7 @@ class BranchLayer(Layer):
         start = time.time()
         branch = ctx.git_branch
         # Hide main/master/dev branches
-        if branch in ("main", "master", "dev", ""):
-            tag = ""
-        else:
-            tag = f"[branch:{branch}]"
+        tag = "" if branch in ("main", "master", "dev", "") else f"[branch:{branch}]"
 
         ms = int((time.time() - start) * 1000)
         return LayerResult(
@@ -427,7 +477,7 @@ class QualityGateLayer(Layer):
     def compute(self, ctx: PromptContext) -> LayerResult:
         start = time.time()
         try:
-            from core.governance.quality_api import list_pending, list_approved
+            from core.governance.quality_api import list_approved, list_pending
 
             pending = list_pending()
             approved = list_approved(limit=3)
@@ -496,6 +546,17 @@ class KnowledgeRetrievalLayer(Layer):
     def cache_ttl(self) -> int:
         return 30
 
+    @property
+    def emits_block(self) -> bool:
+        """The retrieved chunks are a real block, not the tag's value.
+
+        `[knowledge:N chunks]` makes a QUANTIFIED claim about content the
+        model never received before the content channel existed — the
+        loudest unbacked claim in the tag line (QG review). Opting in
+        delivers what the tag advertises.
+        """
+        return True
+
     @property
     def priority(self) -> int:
         return 35
@@ -580,7 +641,10 @@ class KnowledgeRetrievalLayer(Layer):
                 parts.append(f"[cached] {src}: {text}" if src else f"[cached] {text}")
         parts.extend(snippets)
 
-        content = " | ".join(parts)
+        # Self-naming, because the content channel delivers this verbatim to
+        # the model: an unlabelled `[cached] file.md: …` fragment would read
+        # as stray text (the exact defect the opt-in channel exists to avoid).
+        content = f"[arka:knowledge] {' | '.join(parts)}" if parts else ""
         chunk_count = len(snippets) + (len(overlapping) if overlapping else 0)
         # RAG honesty (PR-3 v4.1): keyword-degraded results must never be
         # presented as semantic similarity — label the tag explicitly.
@@ -639,7 +703,7 @@ class ForgeContextLayer(Layer):
         parts = [f"Forge plan: {plan.id} ({plan.status.value})"]
         if plan.critic.confidence > 0:
             decisions = []
-            for source, elements in plan.critic.synthesis.items():
+            for _source, elements in plan.critic.synthesis.items():
                 decisions.extend(elements)
             if decisions:
                 parts.append(f"Decisions: {'; '.join(decisions[:5])}")
@@ -701,7 +765,6 @@ class SessionContextLayer(Layer):
                 layer_id=self.id, tag="", content="", tokens_est=0, compute_ms=0, cached=False
             )
 
-        lines = content.split("\n")
         tag = "[session:resume]"
         tokens = len(content.split())
 
@@ -720,6 +783,8 @@ class SessionContextLayer(Layer):
 # `core.synapse.layers` import paths and helper references keep working.
 
 from core.synapse.layers_kb import (  # noqa: E402,F401
+    _KB_CONFIG_PATH,
+    _MAX_FALLBACK_NOTES,
     KBContextLayer,
     _apply_grounding_policy,
     _build_note_entry,
@@ -732,10 +797,8 @@ from core.synapse.layers_kb import (  # noqa: E402,F401
     _hit_is_inferred,
     _jaccard,
     _jaccard_fallback,
-    _KB_CONFIG_PATH,
     _l25_feature_flag_on,
     _load_fallback_notes,
-    _MAX_FALLBACK_NOTES,
     _note_from_vector_hit,
     _tokenize_for_jaccard,
     _vector_search,

package/core/synapse/layers_base.py

@@ -69,6 +69,22 @@ class Layer(ABC):
         """
         return False
 
+    @property
+    def emits_block(self) -> bool:
+        """True when ``content`` is a self-describing full-text block.
+
+        OPT-IN, and deliberately so. The engine forwards ``content`` to the
+        model only for layers that declare this. Inferring it from
+        ``content != tag`` looked equivalent and was not: most layers set
+        ``content`` to their tag's VALUE (``dev``, ``active``,
+        ``feat/plan-canvas``), so every prompt gained stray unlabeled lines
+        carrying nothing the tag had not already said (QG review).
+
+        A block must stand alone: it names itself (``[arka:kb-context]``,
+        ``[arka:graph-remote unverified]``) and is meaningful without the tag.
+        """
+        return False
+
     @property
     def session_sensitive(self) -> bool:
         """True when compute() has per-session side effects or output.

package/core/synapse/layers_kb.py

@@ -6,12 +6,14 @@ All names are re-exported by core.synapse.layers for backward
 compatibility — import from there unless you need the module itself.
 """
 
+import contextlib
 import json
 import os
 import re
 import time
+import urllib.request
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from core.synapse.layers_base import Layer, LayerResult, PromptContext
 
@@ -23,6 +25,9 @@ _KB_CONFIG_PATH = Path.home() / ".arkaos" / "config.json"
 # (Jaccard ranks the top few notes; scanning 2000 sorted-by-name first
 # is plenty — see `_load_fallback_notes`) while still bounding worst-case latency.
 _MAX_FALLBACK_NOTES = 2000
+# A config.json past this is not a config — refuse it rather than parse it
+# inside the Synapse budget. 4 MiB is ~1000x the real file.
+_MAX_CONFIG_BYTES = 4 * 1024 * 1024
 _KB_STOPWORDS: frozenset[str] = frozenset({
     "a", "an", "the", "and", "or", "but", "in", "on", "at", "to", "for", "of",
     "with", "by", "from", "as", "is", "was", "are", "were", "be", "been", "being",
@@ -34,19 +39,288 @@ _KB_STOPWORDS: frozenset[str] = frozenset({
 })
 
 
+def _read_json_dict(path: Path) -> dict:
+    """Parse ``path`` into a dict, or ``{}``. The single never-raises reader.
+
+    Synapse does not wrap ``layer.compute``, so ANY exception escaping a
+    config read breaks all 12 layers for the turn. Three failure modes are
+    covered together, which is why this is one helper and not three
+    try/excepts: OSError (unreadable), ValueError (bad JSON *and* the
+    UnicodeDecodeError a non-UTF-8 file raises), and RecursionError (deeply
+    nested JSON — neither of the other two, and it escaped in QG review).
+
+    A fourth case needs no ``except`` at all: well-formed JSON whose root is
+    not an object — ``[1,2,3]`` or ``"yes"`` — would raise AttributeError on
+    the first ``.get``, so the return is isinstance-guarded instead.
+    """
+    try:
+        # is_file() excludes a FIFO, whose read_text() blocks FOREVER with no
+        # exception for the net below to catch (QG review). The size cap keeps
+        # a huge file from stalling the ~87ms budget. Both are stat-only.
+        if not path.is_file() or path.stat().st_size > _MAX_CONFIG_BYTES:
+            return {}
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (ValueError, OSError, RecursionError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _section(data: dict, key: str) -> dict:
+    """A dict-valued section of a config, or ``{}`` — never raises."""
+    value = data.get(key)
+    return value if isinstance(value, dict) else {}
+
+
 def _l25_feature_flag_on() -> bool:
     if os.environ.get("ARKA_BYPASS_L25", "").strip() == "1":
         return False
     if not _KB_CONFIG_PATH.exists():
         return True
-    try:
-        data = json.loads(_KB_CONFIG_PATH.read_text(encoding="utf-8"))
-    except (json.JSONDecodeError, OSError):
-        return True
-    synapse_cfg = data.get("synapse") or {}
+    synapse_cfg = _section(_read_json_dict(_KB_CONFIG_PATH), "synapse")
     return bool(synapse_cfg.get("l25KbContext", True))
 
 
+# --- Graphify graph-context pre-injection (opt-in, default OFF) ------------
+# The knowledge graph is a per-user HTTP endpoint. Pre-injecting it costs up
+# to THREE bounded round-trips (initialize → initialized → tools/call), i.e.
+# ~3x _GRAPHIFY_TIMEOUT_S worst case against a ~87ms Synapse budget. That is
+# why it is OFF by default (synapse.l25Graphify) and always fail-open: any
+# missing config, corrupt config, unreachable host, or slow response yields
+# no block and never raises.
+_KEYS_PATH = Path.home() / ".arkaos" / "keys.json"
+_GRAPHIFY_TIMEOUT_S = 0.3
+
+
+def _l25_graphify_flag_on() -> bool:
+    if os.environ.get("ARKA_BYPASS_L25_GRAPHIFY", "").strip() == "1":
+        return False
+    if not _KB_CONFIG_PATH.exists():
+        return False
+    synapse_cfg = _section(_read_json_dict(_KB_CONFIG_PATH), "synapse")
+    return bool(synapse_cfg.get("l25Graphify", False))
+
+
+# The exact ranges ``isPrivateHost`` in installer/graphify.js accepts. Kept
+# as literals rather than ``ip.is_private`` (a strict superset: 0.0.0.0/8,
+# TEST-NET-1/2/3, 240/4, 255.255.255.255 …) so the two implementations cannot
+# drift — tests/python/test_graphify_url_parity.py drives one shared corpus
+# through both and fails on any divergence.
+_PRIVATE_V4 = ("127.0.0.0/8", "10.0.0.0/8", "192.168.0.0/16",
+               "172.16.0.0/12", "169.254.0.0/16")
+_PRIVATE_V6 = ("::1/128", "fc00::/7", "fe80::/10")
+# A whole-host label that is a bare number or 0x-hex, or any dotted form with
+# a 0-prefixed (octal) octet: 134744072, 0x08080808, 0177.0.0.1.
+_OBFUSCATED_IP_RE = re.compile(r"^(?:0[xX][0-9a-fA-F]+|\d+)$|(?:^|\.)0\d")
+
+
+def _ip_is_private(ip: Any) -> bool:
+    """Membership in the explicit private ranges — no is_private shortcut."""
+    import ipaddress
+
+    nets = _PRIVATE_V6 if ip.version == 6 else _PRIVATE_V4
+    return any(ip in ipaddress.ip_network(n) for n in nets)
+
+
+def _is_private_host(raw_host: str) -> bool:
+    """True only for hosts that cannot reach a public endpoint.
+
+    Python mirror of ``isPrivateHost`` in ``installer/graphify.js`` — and the
+    side that resolves the name before opening the socket, so it validates
+    independently of any registration-time check. It is NOT the only sender:
+    ``registerGraphifyHttpMcp`` hands the same token to Claude Code, which
+    then talks to the endpoint on every session (installer/graphify.js).
+
+    A NAME is resolved rather than pattern-matched. Judging the string alone
+    let ``http://134744072/`` through (8.8.8.8 in decimal is a single-label
+    "name" with no dot) and the token went out over plaintext HTTP — captured
+    in QG review. Resolving also closes hex literals and DNS rebinding, since
+    every returned address must be private.
+    """
+    import ipaddress
+    import socket
+
+    host = raw_host.strip()
+    if host.startswith("[") and host.endswith("]"):
+        host = host[1:-1]
+    host = host.rstrip(".")  # trailing-dot FQDN is the same host
+    if not host:
+        return False
+    if "%" in host:  # IPv6 zone-id: strip before parsing
+        host = host.split("%", 1)[0]
+    # Obfuscated IP encodings (decimal 134744072, hex 0x08080808, octal
+    # 0177.0.0.1) have no legitimate use in a configured endpoint and are the
+    # classic filter bypass. Rejected outright, matching the JS twin, rather
+    # than resolved — even when they decode to a private address.
+    if _OBFUSCATED_IP_RE.match(host):
+        return False
+
+    try:
+        return _ip_is_private(ipaddress.ip_address(host))
+    except ValueError:
+        pass
+
+    try:
+        infos = socket.getaddrinfo(host, None, proto=socket.IPPROTO_TCP)
+    except (OSError, UnicodeError):
+        return False  # unresolvable → never send a credential to it
+    if not infos:
+        return False
+    for info in infos:
+        try:
+            addr = ipaddress.ip_address(info[4][0].split("%", 1)[0])
+        except ValueError:
+            return False
+        if not _ip_is_private(addr):
+            return False  # ANY public answer disqualifies the name
+    return True
+
+
+def _valid_graphify_url(raw: str) -> str:
+    """``raw`` when safe to send a credential to, else ''."""
+    if not raw:
+        return ""
+    from urllib.parse import urlsplit
+
+    try:
+        parts = urlsplit(raw)
+    except ValueError:
+        return ""
+    if parts.scheme == "https":
+        return raw
+    if parts.scheme != "http" or not parts.hostname:
+        return ""
+    return raw if _is_private_host(parts.hostname) else ""
+
+
+def _resolve_graphify() -> tuple[str, str]:
+    """(url, token) from config.json + keys.json + env. Empty when unset.
+
+    The URL is validated here and not only in the installer: an unvalidated
+    endpoint plus a token from keys.json is credential redirection, and this
+    function reads ``GRAPHIFY_URL`` straight from the environment.
+    """
+    url = os.environ.get("GRAPHIFY_URL", "").strip()
+    token = os.environ.get("GRAPHIFY_TOKEN", "").strip()
+    gcfg = _section(_section(_read_json_dict(_KB_CONFIG_PATH), "knowledge"), "graphify")
+    if gcfg.get("enabled") is False:
+        return "", ""
+    url = _valid_graphify_url(url or str(gcfg.get("url") or "").strip())
+    if not url:
+        return "", ""
+    if not token and _KEYS_PATH.exists():
+        token = str(_read_json_dict(_KEYS_PATH).get("GRAPHIFY_TOKEN") or "").strip()
+    return url, token
+
+
+class _NoRedirect(urllib.request.HTTPRedirectHandler):
+    """Refuse every redirect.
+
+    urllib copies non-content headers across a redirect, so a 302 from the
+    graph server would forward ``Authorization: Bearer <token>`` to whatever
+    host it names — reproduced end-to-end in QG review. An MCP endpoint has
+    no legitimate reason to redirect, so the safe answer is to never follow.
+    """
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+def _graphify_post(url: str, headers: dict, payload: dict, extra: dict | None = None):
+    """One bounded MCP POST. Raises on transport failure — callers guard."""
+    body = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(url, data=body, headers={**headers, **(extra or {})})
+    opener = urllib.request.build_opener(_NoRedirect)
+    return opener.open(req, timeout=_GRAPHIFY_TIMEOUT_S)
+
+
+def _graphify_open_session(url: str, headers: dict) -> dict:
+    """Initialize the MCP session; returns the session-id header dict."""
+    init = {
+        "jsonrpc": "2.0", "id": 1, "method": "initialize",
+        "params": {
+            "protocolVersion": "2024-11-05", "capabilities": {},
+            "clientInfo": {"name": "synapse-l25", "version": "1.0"},
+        },
+    }
+    with _graphify_post(url, headers, init) as resp:
+        session_id = resp.headers.get("Mcp-Session-Id", "")
+    sid_header = {"Mcp-Session-Id": session_id} if session_id else {}
+    # Some MCP servers require the initialized notification before a
+    # tools/call; servers that do not need it ignore the extra request.
+    with contextlib.suppress(Exception):
+        _graphify_post(
+            url, headers,
+            {"jsonrpc": "2.0", "method": "notifications/initialized"}, sid_header,
+        ).close()
+    return sid_header
+
+
+def _graphify_parse_sse(raw: str) -> dict | None:
+    """First JSON object in an SSE or plain JSON-RPC response body."""
+    for line in raw.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("data:"):
+            stripped = stripped[5:].strip()
+        if not stripped:
+            continue
+        try:
+            return json.loads(stripped)
+        except ValueError:
+            continue
+    return None
+
+
+def _graphify_query(prompt: str, url: str, token: str) -> str | None:
+    """Best-effort MCP `query_graph` over streamable HTTP. Never raises.
+
+    Returns the graph text-context, or None on any failure/timeout. Each of
+    the up-to-three requests is bounded by ``_GRAPHIFY_TIMEOUT_S``, so a fully
+    unresponsive endpoint costs ~3x that before this gives up and falls open.
+    """
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json",
+        "Accept": "application/json, text/event-stream",
+    }
+    try:
+        sid_header = _graphify_open_session(url, headers)
+        call = {
+            "jsonrpc": "2.0", "id": 2, "method": "tools/call",
+            "params": {"name": "query_graph", "arguments": {"query": prompt[:200]}},
+        }
+        with _graphify_post(url, headers, call, sid_header) as resp:
+            raw = resp.read().decode("utf-8", errors="replace")
+        data = _graphify_parse_sse(raw)
+        if not data:
+            return None
+        content = (data.get("result") or {}).get("content") or []
+        texts = [c.get("text", "") for c in content if c.get("type") == "text"]
+        return "\n".join(t for t in texts if t).strip() or None
+    except Exception:
+        return None
+
+
+def _graphify_context(prompt: str) -> str:
+    """Formatted ``[arka:graph-remote]`` block, or '' — fail-open.
+
+    Deliberately NOT ``[arka:graph-context]``: L2.7 GraphContextLayer already
+    owns that marker for the LOCAL graph, under a stricter contract (never
+    truncates a source location, never injects AMBIGUOUS nodes). This block
+    comes from a remote server, is not confidence-filtered, and is clipped to
+    a byte budget — same marker, contradictory guarantees, so it gets its own.
+    """
+    if not prompt or not _l25_graphify_flag_on():
+        return ""
+    url, token = _resolve_graphify()
+    if not url or not token:
+        return ""
+    text = _graphify_query(prompt, url, token)
+    if not text:
+        return ""
+    excerpt = text[:600].rstrip()
+    return f"[arka:graph-remote unverified]\n{excerpt}\n"
+
+
 def _tokenize_for_jaccard(text: str) -> set[str]:
     if not text:
         return set()
@@ -121,7 +395,13 @@ def _format_kb_block(notes: list[dict], degraded: bool = False) -> str:
         path = note.get("path", "")
         excerpt = note.get("excerpt", "")
         relates = note.get("relates", []) or []
-        suffix = " (inferred — not authoritative)" if note.get("inferred") else ""
+        # Deliberately pt-PT: this block is operator-facing and every other
+        # string in it is pt-PT (header, Excerto, Relacionada, the degraded
+        # warning). The label was the lone English fragment. The RAG-honesty
+        # contract is unchanged — only the wording — and the two assertions
+        # guarding it in test_rag_honesty.py were updated in the same change
+        # for that reason, not to make a failing test pass.
+        suffix = " (inferida — não autoritativa)" if note.get("inferred") else ""
         lines.append(f"- [[{title}]]{suffix} (path: `{path}`)")
         if excerpt:
             lines.append(f"  Excerto: {excerpt}")
@@ -160,7 +440,7 @@ def _jaccard_fallback(
     return [n for _, n in scored[:top_k]]
 
 
-def _load_fallback_notes(vault_path: Optional[Path]) -> list[dict]:
+def _load_fallback_notes(vault_path: Path | None) -> list[dict]:
     if vault_path is None or not vault_path.exists() or not vault_path.is_dir():
         return []
     notes: list[dict] = []
@@ -211,7 +491,7 @@ def _hit_is_inferred(hit: dict) -> bool:
     if not source:
         return False
     try:
-        with open(source, "r", encoding="utf-8", errors="ignore") as fh:
+        with open(source, encoding="utf-8", errors="ignore") as fh:
             head = fh.read(2048)
     except OSError:
         return False
@@ -246,7 +526,7 @@ def _apply_grounding_policy(notes: list[dict], max_notes: int) -> list[dict]:
     """Quarantine inferred notes (Dreaming output) from grounded context.
 
     Policy (PR-3 v4.1): inferred notes are EXCLUDED by default; they are
-    only included — explicitly suffixed `(inferred — not authoritative)`
+    only included — explicitly suffixed `(inferida — não autoritativa)`
     by the formatter — when fewer than 2 grounded notes matched.
     """
     grounded = [n for n in notes if not n.get("inferred")]
@@ -277,7 +557,7 @@ class KBContextLayer(Layer):
     def __init__(
         self,
         vector_store: Any = None,
-        vault_path: Optional[str] = None,
+        vault_path: str | None = None,
         max_notes: int = 5,
         min_similarity: float = 0.5,
     ) -> None:
@@ -302,6 +582,11 @@ class KBContextLayer(Layer):
     def cache_ttl(self) -> int:
         return 0
 
+    @property
+    def emits_block(self) -> bool:
+        """Content is the self-naming [arka:kb-context] / graph block."""
+        return True
+
     @property
     def priority(self) -> int:
         return 25
@@ -360,7 +645,7 @@ class KBContextLayer(Layer):
         ]
         return _apply_grounding_policy(fallback_notes, self._max_notes), False
 
-    def build(self, prompt: str) -> Optional[str]:
+    def build(self, prompt: str) -> str | None:
         """Public entrypoint — returns the formatted block or None."""
         if not prompt or not _l25_feature_flag_on():
             return None
@@ -369,6 +654,28 @@ class KBContextLayer(Layer):
             return None
         return _format_kb_block(notes[: self._max_notes], degraded=degraded)
 
+    def _safe_graph_block(self, prompt: str) -> str:
+        """Graphify block, or ''. Guarded: Synapse does not wrap compute."""
+        try:
+            return _graphify_context(prompt)
+        except Exception:
+            return ""
+
+    def _render(self, notes: list[dict], degraded: bool, graph_block: str) -> tuple[str, str]:
+        """(content, tag) for the assembled KB + graph context."""
+        parts = []
+        if notes:
+            parts.append(_format_kb_block(notes[: self._max_notes], degraded=degraded))
+        if graph_block:
+            parts.append(graph_block)
+        tag = (
+            f"[kb-context:{len(notes)} degraded=keyword]" if degraded
+            else f"[kb-context:{len(notes)}]"
+        )
+        if graph_block:
+            tag = f"{tag[:-1]} +graph]"
+        return "\n".join(parts), tag
+
     def compute(self, ctx: PromptContext) -> LayerResult:
         start = time.time()
         if not ctx.user_input or not _l25_feature_flag_on():
@@ -378,18 +685,17 @@ class KBContextLayer(Layer):
         except Exception:
             return self._empty(start)
         self._record(ctx, len(notes))
-        if not notes:
+        # Graphify graph-context is opt-in (default OFF) — a cheap no-op when
+        # the flag is off, and always fail-open so it never blocks Obsidian.
+        graph_block = self._safe_graph_block(ctx.user_input[:2000])
+        if not notes and not graph_block:
             return self._empty(start)
-        block = _format_kb_block(notes[: self._max_notes], degraded=degraded)
-        ms = int((time.time() - start) * 1000)
-        tag = f"[kb-context:{len(notes)}]"
-        if degraded:
-            tag = f"[kb-context:{len(notes)} degraded=keyword]"
+        block, tag = self._render(notes, degraded, graph_block)
         return LayerResult(
             layer_id=self.id,
             tag=tag,
             content=block,
             tokens_est=len(block.split()),
-            compute_ms=ms,
+            compute_ms=int((time.time() - start) * 1000),
             cached=False,
         )

package/dashboard/app/layouts/default.vue

@@ -80,6 +80,13 @@ const links = [[{
   onSelect: () => {
     open.value = false
   }
+}, {
+  label: 'Plan Canvas',
+  icon: 'i-lucide-drafting-compass',
+  to: '/plan-canvas',
+  onSelect: () => {
+    open.value = false
+  }
 }, {
   label: 'Knowledge',
   icon: 'i-lucide-brain',