marvisx-cli 0.3.8b3__tar.gz → 0.3.8b6__tar.gz

{marvisx_cli-0.3.8b3 → marvisx_cli-0.3.8b6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: marvisx-cli
-Version: 0.3.8b3
+Version: 0.3.8b6
 Summary: MarvisX OSS — agent-native company-brain CLI runtime (init, status, brief, triage)
 Author: MarvisX maintainers
 License: BSL-1.1

{marvisx_cli-0.3.8b3 → marvisx_cli-0.3.8b6}/core/api/config.py

@@ -125,6 +125,13 @@ class Settings(BaseSettings):
         default=86400, alias="BRAIN_WAREHOUSE_CONSOLIDATION_INTERVAL_SECONDS"
     )
 
+    # KG temporal recency pass (Fase D producer): proposes re-verifying aging,
+    # never-verified live nodes. Gated by temporal_memory_enabled (no separate
+    # enable flag — the flag IS the gate). Daily cadence guard.
+    brain_temporal_recency_interval_seconds: int = Field(
+        default=86400, alias="BRAIN_TEMPORAL_RECENCY_INTERVAL_SECONDS"
+    )
+
     # GitHub Webhook
     github_webhook_secret: str = ""
 
@@ -475,6 +482,47 @@ class Settings(BaseSettings):
         default=False, alias="MARVIS_TEMPORAL_MEMORY"
     )
 
+    # answer-ready claims (DEFAULT OFF). When False every reasoning-tool read is
+    # byte-identical to today (no `claims` key). When True, project_impact/
+    # graph_impact append a `claims[]` block: server-computed, relation-typed
+    # counts with provenance — the agent reports the value instead of re-counting
+    # raw edges (faithfulness). Separate from temporal_memory so grounding can be
+    # enabled without the freshness surface. See plan 2026-06-08-feat-answer-ready-claims.
+    kg_claims_enabled: bool = Field(
+        default=False, alias="MARVIS_KG_CLAIMS"
+    )
+
+    # Memory-freshness v2a Phase 1 (B-fix, DEFAULT OFF). The documents_fts
+    # INSERT/UPDATE triggers (migration 136) write file_path into the content
+    # column, so every doc written AFTER the one-time migration backfill has NO
+    # body in the lexical lane (prod 2026-06-09: 100% of recent docs degraded
+    # → the BM25 lane sees OLD bodies but never NEW ones — a direct stale-
+    # retrieval mechanism). When True, every documents upsert path additionally
+    # overwrites the trigger-degraded FTS row with the real title+body
+    # (refresh_documents_fts_row). When False the refresh helper is a no-op and
+    # behavior is byte-identical to today. The one-shot backfill script
+    # (scripts/backfill_documents_fts.py) repairs historical rows; in prod the
+    # flag must flip ON at backfill time and stay on, otherwise the next doc
+    # update re-degrades its row. See plan
+    # 2026-06-09-feat-memory-freshness-v2a-retrieval.
+    fts_bodies_enabled: bool = Field(
+        default=False, alias="MARVIS_FTS_BODIES"
+    )
+
+    # Memory-freshness v2a Phase 2 (A-span, DEFAULT OFF). When False the search
+    # read path never touches the chunks/vec_chunks sidecars and the response is
+    # byte-identical to today (no span_* fields populated). When True (and
+    # MARVIS_CHUNKING populated the sidecars), the semantic lane max-pools
+    # chunk-KNN hits into the doc ranking and each file-backed hit carries the
+    # winning chunk's span expanded to line boundaries ±12 lines (span_text /
+    # span_path / span_line_start / span_line_end) so the agent can answer FROM
+    # the search result without a follow-up Read. Write-side chunking stays
+    # gated by MARVIS_CHUNKING (env, read per-call). See plan
+    # 2026-06-09-feat-memory-freshness-v2a-retrieval.
+    search_spans_enabled: bool = Field(
+        default=False, alias="MARVIS_SEARCH_SPANS"
+    )
+
     # Track 2 #3c — community summaries in the brief (GraphRAG global-search,
     # DEFAULT OFF). When False the brief is byte-identical to today: the
     # communities/community_summary modules are a flag-gated library + seam,
@@ -517,6 +565,15 @@ class Settings(BaseSettings):
     brain_llm_polish_enabled: bool = Field(
         default=True, alias="BRAIN_LLM_POLISH_ENABLED"
     )
+    # P1: pick the Brain LLM backend. "gateway" (default, unchanged) = the HTTP
+    # Mac-gateway client (requires BRAIN_LLM_GATEWAY_API_KEY). "claude_cli" = run
+    # `claude -p` headless on the user's Claude Code subscription (NO API key) —
+    # see core/api/services/brain/llm/claude_cli.py.
+    brain_llm_provider: Literal["gateway", "claude_cli"] = Field(
+        default="gateway", alias="BRAIN_LLM_PROVIDER"
+    )
+    # Path/name of the `claude` binary for the claude_cli provider.
+    marvis_claude_bin: str = Field(default="claude", alias="MARVIS_CLAUDE_BIN")
     brain_llm_journal_polish_enabled: bool = Field(
         default=True, alias="BRAIN_LLM_JOURNAL_POLISH_ENABLED"
     )

{marvisx_cli-0.3.8b3 → marvisx_cli-0.3.8b6}/core/api/mcp/server.py

@@ -46,6 +46,10 @@ _INSTRUCTIONS = (
     "Before answering an orchestration or planning task, confirm you actually called the relevant "
     "tool (session_brief / project_impact / graph_impact) AND that your answer addresses the task "
     "as asked — do not reply from raw files or pivot to an unrelated skill.\n"
+    "When you state a number from the knowledge graph (a count, in-degree, how many dependents), "
+    "quote it from the tool result's `summary` block and cite it inline — e.g. \"148 edges from 11 "
+    "sources [graph_neighbors summary]\". Do NOT re-count a returned list by hand, and do NOT state a "
+    "count that no tool result supports.\n"
 )
 
 mcp = FastMCP("marvis", instructions=_INSTRUCTIONS)

{marvisx_cli-0.3.8b3 → marvisx_cli-0.3.8b6}/core/api/mcp/tools/graph.py

@@ -124,9 +124,10 @@ def register(mcp) -> None:
         as_of: Annotated[str, Field(pattern=_AS_OF_PATTERN, max_length=32)] | None = None,
     ) -> dict[str, Any]:
         """1-hop: chi tocca / dipende direttamente da un nodo. Funziona su codice ('py:function:...') E su progetti ('project:artifact:<slug>').
-        ORCHESTRAZIONE: per i vicini diretti di un PROGETTO (chi dipende da X) passa node_id='project:artifact:<slug>' con edge_types=['depends_on']. Codice: caller/callee 1-hop di una function.
-        QUANDO USARLO: vicinato diretto senza il bundle completo; caller inattesi; time-travel as_of; rank=suspect_write per bug write-through-read. Per il blast radius transitivo usa graph_impact / project_impact.
-        RESTITUISCE: list of {node_id, relation, direction, rank_score?, freshness} cap 200."""
+        CHI DIPENDE DA X (in UNA call): graph_neighbors(node_id, direction='incoming', rank='degree') → i dipendenti diretti ordinati per grado + un blocco `summary` GIA' aggregato. E' il tool ovvio per 'chi cita / dipende da X' — NON fare N micro-query (project_impact e' il primo passo, non N).
+        ORCHESTRAZIONE: per i vicini diretti di un PROGETTO passa node_id='project:artifact:<slug>' con edge_types=['depends_on']. Codice: caller/callee 1-hop di una function.
+        QUANDO USARLO: vicinato diretto; caller inattesi; time-travel as_of; rank=suspect_write per bug write-through-read. Per il blast radius transitivo usa graph_impact / project_impact.
+        RESTITUISCE: {neighbors:[{node_id, relation, direction, rank_score?}], summary:{total, distinct_nodes, by_relation, by_direction} (CITA questi numeri, non ricontare la lista), freshness} cap 200."""
         try:
             async with acquire_db() as db:
                 # Node proxy hardcodes limit=200 (the surface exposes no limit param).
@@ -205,7 +206,7 @@ def register(mcp) -> None:
         """Portfolio blast radius: 'se pauso / chiudo / de-prioritizzo questo PROGETTO, quali altri progetti si bloccano?'. Il tool di prima classe per l'orchestrazione cross-progetto — distinto dal grafo-codice.
         Risolve 'project:artifact:<slug>' e fa l'impact BFS sui soli edge progetto->progetto (depends_on / mentions / refers_to). La response porta il segnale freshness (indexed_sha vs HEAD) per non fidarsi di un indice stantio.
         QUANDO USARLO: prima di pausare/chiudere/de-prioritizzare un progetto; sequenziare un portafoglio (cosa sblocca cosa); capire le dipendenze cross-progetto di una decisione.
-        RESTITUISCE: {direct_dependents[], transitive_list[], rank_score, freshness}."""
+        RESTITUISCE: {direct_dependents[], transitive_list[], rank_score, freshness}. Col flag MARVIS_KG_CLAIMS anche claims[]: quanti progetti dipendono DAVVERO da questo (kind=dependents_depends_on) vs quanti lo nominano soltanto (kind=mentioned_by), gia' contati server-side con provenienza e freschezza — riporta quei numeri, non ri-contare le liste."""
         try:
             async with acquire_db() as db:
                 result = await graph_uc.graph_impact(

{marvisx_cli-0.3.8b3 → marvisx_cli-0.3.8b6}/core/api/models/graph_ux.py

@@ -13,7 +13,38 @@ from __future__ import annotations
 from datetime import datetime
 from typing import Literal
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+# ---------------------------------------------------------------------------
+# answer-ready claims (behind MARVIS_KG_CLAIMS) — server-computed, relation-typed
+# ---------------------------------------------------------------------------
+
+class KGClaim(BaseModel):
+    """A server-computed claim about a KG node: the value is counted by the DB,
+    not by the agent. The agent reports it (and the relation) instead of
+    re-counting raw edges — this is the faithfulness fix.
+
+    `kind` names the relation explicitly (e.g. `dependents_depends_on` = real
+    dependency, `mentioned_by` = associative, NOT a dependency). `sources` is a
+    capped sample of the provenance; `sources_total` is the full count.
+    """
+    model_config = ConfigDict(extra="forbid")
+
+    kind: str = Field(..., description="dependents_depends_on | dependents_imports | dependents_calls | mentioned_by")
+    subject: str = Field(..., description="node_id the claim is about")
+    value: int = Field(..., ge=0, description="server-computed count (the number to report)")
+    sources: list[str] = Field(default_factory=list, description="capped sample of source node ids (provenance)")
+    sources_total: int = Field(..., ge=0, description="full provenance count before capping")
+    as_of: str | None = Field(None, description="last observation (last_seen_at) of the subject")
+    verified: str | None = Field(None, description="last Brain re-confirmation (last_verified_at), or null")
+    needs_review: bool = Field(False, description="subject is stale per the read-time freshness budget")
+
+    @model_validator(mode="after")
+    def _sources_within_total(self) -> "KGClaim":
+        if self.sources_total < len(self.sources):
+            raise ValueError("sources_total must be >= len(sources)")
+        return self
+
 
 # ---------------------------------------------------------------------------
 # Shared type alias (validated at model-field level via annotation)
@@ -47,6 +78,36 @@ class PinOut(BaseModel):
     is_stale: bool = False  # True if node was soft-deleted after pinning (belt-and-braces)
 
 
+# ---------------------------------------------------------------------------
+# Fase D — KG trust write-path request bodies (behind MARVIS_TEMPORAL_MEMORY).
+# The apply actions an agent performs after Triage approves a Brain proposal.
+# ---------------------------------------------------------------------------
+
+class VerifyNodeIn(BaseModel):
+    """Request body for POST /graph/nodes/verify — stamp last_verified_at = now."""
+    node_id: str = Field(
+        ...,
+        min_length=6,
+        max_length=256,
+        pattern=r"^[a-z]+:[a-z]+:.+$",
+        description="Node ID to mark re-verified (REINFORCE apply)",
+    )
+
+
+class SupersedeEdgeIn(BaseModel):
+    """Request body for POST /graph/edges/supersede — soft-invalidate an edge."""
+    source_id: str = Field(..., min_length=6, max_length=256, pattern=r"^[a-z]+:[a-z]+:.+$")
+    target_id: str = Field(..., min_length=6, max_length=256, pattern=r"^[a-z]+:[a-z]+:.+$")
+    relation: str = Field(
+        ..., min_length=2, max_length=32,
+        description="Edge relation of the triple to supersede (e.g. depends_on)",
+    )
+    superseded_by: str | None = Field(
+        None, max_length=256,
+        description="Optional audit pointer to the replacing edge",
+    )
+
+
 # ---------------------------------------------------------------------------
 # Landing bundle
 # ---------------------------------------------------------------------------

{marvisx_cli-0.3.8b3 → marvisx_cli-0.3.8b6}/core/api/models/search.py

@@ -26,6 +26,14 @@ class SearchHit(BaseModel):
     edge_path: list[str] | None = None
     edge_path_summary: str | None = None
     rrf_score: float | None = None
+    # Memory-freshness v2a Phase 2 (A-span, MARVIS_SEARCH_SPANS): the winning
+    # chunk's text expanded to line boundaries ±12 lines, so the agent answers
+    # FROM the result without a follow-up Read. None when the flag is off, the
+    # hit is row-backed (task/learning/inbox), or the source file is gone.
+    span_text: str | None = None
+    span_path: str | None = None
+    span_line_start: int | None = None
+    span_line_end: int | None = None
 
 
 class SearchResponse(BaseModel):

{marvisx_cli-0.3.8b3 → marvisx_cli-0.3.8b6}/core/api/routers/graph.py

@@ -79,6 +79,8 @@ from core.api.models.graph_ux import (
     PinIn,
     PinOut,
     ResolveOut,
+    SupersedeEdgeIn,
+    VerifyNodeIn,
 )
 from core.api.models.graph_cosmo import GraphCosmoOut
 from core.api.rate_limit import limiter
@@ -701,6 +703,54 @@ async def delete_graph_pin(
     return result
 
 
+# --- KG trust write-path (Fase D, behind MARVIS_TEMPORAL_MEMORY) ---
+
+@router.post("/nodes/verify", response_model=dict, summary="Mark a KG node re-verified")
+@limiter.limit("60/minute")
+async def mark_node_verified(
+    body: VerifyNodeIn,
+    request: Request,
+    user: UserInfo = Depends(get_current_user_or_agent),
+    db: aiosqlite.Connection = Depends(get_write_db),
+) -> dict:
+    """Stamp graph_nodes.last_verified_at = now (REINFORCE apply).
+
+    The action an agent performs after Triage approves a Brain recency proposal.
+    Inert (422) when MARVIS_TEMPORAL_MEMORY is off. 404 if the node is missing.
+    """
+    ctx = CallerContext.from_user_info(user, is_human_session=False)
+    try:
+        return await uc.mark_node_verified(ctx, db, node_id=body.node_id)
+    except ServiceError as e:
+        raise to_http_legacy(e)
+
+
+@router.post("/edges/supersede", response_model=dict, summary="Soft-invalidate a KG edge")
+@limiter.limit("60/minute")
+async def mark_edge_superseded(
+    body: SupersedeEdgeIn,
+    request: Request,
+    user: UserInfo = Depends(get_current_user_or_agent),
+    db: aiosqlite.Connection = Depends(get_write_db),
+) -> dict:
+    """Set graph_edges.valid_until = now (+ optional superseded_by) on a triple.
+
+    SUPERSEDE / CONTRADICTION apply. Soft, never deletes. Inert (422) when the
+    flag is off. 404 if the triple is absent.
+    """
+    ctx = CallerContext.from_user_info(user, is_human_session=False)
+    try:
+        return await uc.mark_edge_superseded(
+            ctx, db,
+            source_id=body.source_id,
+            target_id=body.target_id,
+            relation=body.relation,
+            superseded_by=body.superseded_by,
+        )
+    except ServiceError as e:
+        raise to_http_legacy(e)
+
+
 # --- Resolve file path → node_id ---
 
 @router.get("/resolve", response_model=ResolveOut, summary="Resolve file path to KG node")

{marvisx_cli-0.3.8b3 → marvisx_cli-0.3.8b6}/core/api/services/brain/jobs.py

@@ -237,6 +237,40 @@ async def _warehouse_consolidation_due(
     return elapsed >= interval_seconds
 
 
+async def _temporal_recency_due(
+    *, workspace_id: str, now: datetime, interval_seconds: int
+) -> bool:
+    """Daily cadence guard for the KG temporal recency pass (Fase D).
+
+    Derives "last run" from the newest persisted recency proposal — these are
+    `operation_type='reinforce'` ops whose proposed_write target_type is 'none'
+    (M1 reinforce uses 'kg_edge_metric', so this filter isolates the recency
+    pass). Idempotent regardless (operation_id collision dedups within a cycle),
+    so a missing/unparseable timestamp falls back to "due".
+    """
+    if interval_seconds <= 0:
+        return True
+    async with acquire_db() as db:
+        row = await (
+            await db.execute(
+                "SELECT MAX(detected_at) FROM brain_memory_operations"
+                " WHERE operation_type = 'reinforce'"
+                "  AND proposed_write_target_type = 'none'",
+            )
+        ).fetchone()
+    last_raw = row[0] if row else None
+    if not last_raw:
+        return True
+    try:
+        last_dt = datetime.fromisoformat(str(last_raw).replace("Z", "+00:00"))
+    except ValueError:
+        return True
+    if last_dt.tzinfo is None:
+        last_dt = last_dt.replace(tzinfo=timezone.utc)
+    elapsed = (now.astimezone(timezone.utc) - last_dt.astimezone(timezone.utc)).total_seconds()
+    return elapsed >= interval_seconds
+
+
 def _cycle_window_from_key(
     cycle_key: str, *, cutoff_hour_utc: int
 ) -> tuple[datetime, datetime]:
@@ -563,6 +597,44 @@ async def _execute_cycle(
                     SourceFailure(source_system="warehouse_consolidation", error=str(exc))
                 )
 
+        # Phase 4c — KG temporal recency (Fase D producer). Ships DORMANT: gated
+        # on temporal_memory_enabled (the MARVIS_TEMPORAL_MEMORY flag IS the gate;
+        # default off → skipped). When on, a daily cadence guard bounds re-emission.
+        # PROPOSALS only — never auto-applied. Isolated try/except so it can NEVER
+        # crash the cycle.
+        if app_settings.temporal_memory_enabled:
+            try:
+                from core.api.services.brain.temporal_recency import (
+                    run_temporal_recency,
+                )
+
+                if await _temporal_recency_due(
+                    workspace_id=workspace_id,
+                    now=now,
+                    interval_seconds=app_settings.brain_temporal_recency_interval_seconds,
+                ):
+                    tr_summary = await run_temporal_recency(
+                        run_id=run_id,
+                        cycle_key=cycle_key,
+                        workspace_id=workspace_id,
+                        now=now,
+                    )
+                    logger.info(
+                        "brain.jobs: temporal recency run_id=%s summary=%s",
+                        run_id,
+                        tr_summary,
+                    )
+                else:
+                    logger.info(
+                        "brain.jobs: temporal recency skipped (cadence guard) run_id=%s",
+                        run_id,
+                    )
+            except Exception as exc:  # noqa: BLE001 — phase-level isolation
+                logger.exception("brain.jobs: temporal recency failed")
+                failures.append(
+                    SourceFailure(source_system="temporal_recency", error=str(exc))
+                )
+
         # Phase 5 — Learn Findings (sub-04). Final L5 phase of the cycle.
         # Consumes digest events + journal entries + drift signals + memory
         # operations of the current run_id (NEVER re-reads substrate).

marvisx_cli-0.3.8b6/core/api/services/brain/llm/claude_cli.py

@@ -0,0 +1,201 @@
+# v1.0.0 - 2026-06-09 - P1: claude -p (Claude Code headless) provider for the Brain.
+"""Brain LLM backend that runs `claude -p` (Claude Code headless) as a subprocess.
+
+The brain runs on the user's Claude Code **subscription** — zero API key. Selected
+with `BRAIN_LLM_PROVIDER=claude_cli`; the default `gateway` path is unchanged.
+
+Same `BrainLLMService` contract as `LocalGatewayBrainService` (call_polish / call_json
+/ aclose + model / grounding_strict). Only the transport differs: instead of an HTTP
+chat.completion, we exec `claude -p --output-format json`, write the user prompt to
+**stdin**, and read the single-result envelope. Verified flags/schema against the
+installed binary (2026-06-09): envelope `{result: str, is_error: bool, …}`.
+
+CRITICAL: `claude -p` is an AGENT by default (loads the Claude Code system prompt,
+may use tools). For pure generation we pass `--allowedTools ""` (no tools),
+`--system-prompt <brain>` (replace, not append) + `--exclude-dynamic-system-prompt-sections`
+(strip the agentic preamble). Everything fails SOFT: any error/timeout/non-zero
+exit/malformed JSON → PolishResult.failed (or None for call_json) → the brain
+degrades to its deterministic baseline, never a crash.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import shutil
+from contextlib import suppress
+from typing import Any
+
+from core.api.services.brain.llm.base import PolishPurpose, PolishResult
+from core.api.services.brain.llm.direction_alignment import (
+    classify_direction_alignment_impl,
+)
+from core.api.services.brain.llm.local_gateway import _project_polished_fields
+from core.api.services.brain.llm.parsers import ParseError, parse_json_or_raise
+
+logger = logging.getLogger(__name__)
+
+
+class ClaudeCliBrainService:
+    """Brain polish via `claude -p` headless on the local Claude Code subscription."""
+
+    def __init__(
+        self,
+        *,
+        model: str,
+        binary: str = "claude",
+        timeout_seconds: int = 60,
+        semaphore_size: int = 1,
+        grounding_strict: bool = False,
+    ) -> None:
+        self._model = model or ""
+        self._binary = binary or "claude"
+        self._timeout_seconds = max(5, int(timeout_seconds))
+        # Subprocess is heavy (CLI boot per call); keep concurrency low.
+        self._semaphore = asyncio.Semaphore(max(1, int(semaphore_size)))
+        self._grounding_strict = grounding_strict
+
+    @property
+    def model(self) -> str:
+        return self._model
+
+    @property
+    def grounding_strict(self) -> bool:
+        return self._grounding_strict
+
+    async def aclose(self) -> None:
+        # No persistent client/process to release.
+        return None
+
+    # ----------------------------------------------------------------- #
+    # subprocess transport                                              #
+    # ----------------------------------------------------------------- #
+
+    async def _run(self, *, system_prompt: str, user_prompt: str) -> tuple[str | None, str]:
+        """Run `claude -p` once. Returns (content, "") on success, (None, reason) on
+        any failure. `content` is the assistant text (the envelope's `result`)."""
+        if not os.path.isabs(self._binary) and shutil.which(self._binary) is None:
+            return (None, "claude_not_on_path")
+
+        argv = [
+            self._binary,
+            "-p",
+            "--output-format", "json",
+            "--allowedTools", "",  # no tools → pure generation, no agent loop
+            "--exclude-dynamic-system-prompt-sections",  # drop the Claude Code agentic preamble
+            "--system-prompt", system_prompt,
+        ]
+        if self._model:
+            argv += ["--model", self._model]
+
+        async with self._semaphore:
+            try:
+                proc = await asyncio.create_subprocess_exec(
+                    *argv,
+                    stdin=asyncio.subprocess.PIPE,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+            except Exception as exc:  # binary missing / exec error
+                return (None, f"spawn_failed:{exc}")
+            try:
+                out, err = await asyncio.wait_for(
+                    proc.communicate(user_prompt.encode("utf-8")),
+                    timeout=self._timeout_seconds,
+                )
+            except asyncio.TimeoutError:
+                proc.kill()
+                with suppress(Exception):
+                    await proc.wait()
+                return (None, "timeout")
+            except Exception as exc:
+                return (None, f"communicate_failed:{exc}")
+
+        if proc.returncode != 0:
+            tail = err.decode("utf-8", "replace")[:200] if err else ""
+            return (None, f"exit_{proc.returncode}:{tail}")
+
+        try:
+            env = json.loads(out.decode("utf-8"))
+        except Exception:
+            return (None, "envelope_not_json")
+        if not isinstance(env, dict):
+            return (None, "envelope_not_object")
+        if env.get("is_error"):
+            return (None, f"claude_error:{str(env.get('result'))[:200]}")
+
+        content = env.get("result")
+        if not isinstance(content, str) or not content.strip():
+            # Tolerant of schema drift: fall back to the first non-empty string field.
+            content = next(
+                (v for v in env.values() if isinstance(v, str) and v.strip()), ""
+            )
+        if not content:
+            return (None, "empty_result")
+        return (content, "")
+
+    # ----------------------------------------------------------------- #
+    # BrainLLMService contract                                          #
+    # ----------------------------------------------------------------- #
+
+    async def call_polish(
+        self,
+        *,
+        purpose: PolishPurpose,
+        system_prompt: str,
+        user_prompt: str,
+        max_tokens: int,
+        idempotency_key: str | None = None,
+    ) -> PolishResult:
+        """Issue the polish call. Never raises — returns PolishResult.failed on errors.
+        Shares the content→PolishResult projection with the gateway provider."""
+        content, reason = await self._run(system_prompt=system_prompt, user_prompt=user_prompt)
+        if content is None:
+            logger.warning("brain_claude_cli_polish_failed purpose=%s reason=%s", purpose, reason)
+            return PolishResult.failed(purpose=purpose, reason=reason, model=self._model)
+        try:
+            parsed = parse_json_or_raise(content)
+        except ParseError as exc:
+            return PolishResult.failed(
+                purpose=purpose, reason=f"json_parse_failed:{exc}", model=self._model
+            )
+        polished, cited = _project_polished_fields(purpose=purpose, parsed=parsed)
+        if not polished:
+            return PolishResult.failed(
+                purpose=purpose, reason="polished_fields_missing", model=self._model
+            )
+        return PolishResult(
+            success=True,
+            purpose=purpose,
+            polished=polished,
+            cited_evidence_refs=cited,
+            model=self._model,
+        )
+
+    async def call_json(
+        self,
+        *,
+        model: str,
+        system_prompt: str,
+        user_prompt: str,
+        max_tokens: int,
+        temperature: float,
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any] | None:
+        """Generic JSON-object call (DR8 classifier). The per-call `model` is a
+        gateway model id with no Claude equivalent, so the configured Claude model
+        (`self._model`) is used. None on any failure — caller falls back."""
+        content, reason = await self._run(system_prompt=system_prompt, user_prompt=user_prompt)
+        if content is None:
+            logger.warning("brain_claude_cli_json_failed reason=%s", reason)
+            return None
+        try:
+            return parse_json_or_raise(content)
+        except ParseError as exc:
+            logger.warning("brain_claude_cli_json_parse_failed reason=%s", str(exc))
+            return None
+
+    async def classify_direction_alignment(self, payload: dict[str, Any]) -> dict[str, Any] | None:
+        """DR8 classifier surface — same impl the gateway provider uses."""
+        return await classify_direction_alignment_impl(llm_surface=self, payload=payload)

{marvisx_cli-0.3.8b3 → marvisx_cli-0.3.8b6}/core/api/services/brain/llm/factory.py

@@ -93,6 +93,19 @@ def get_brain_llm_service() -> BrainLLMService:
         _brain_llm_service = _NoOpBrainLLMService()
         return _brain_llm_service
 
+    # P1: claude -p provider runs on the Claude Code subscription — NO api key.
+    if getattr(settings, "brain_llm_provider", "gateway") == "claude_cli":
+        from core.api.services.brain.llm.claude_cli import ClaudeCliBrainService
+
+        _brain_llm_service = ClaudeCliBrainService(
+            binary=getattr(settings, "marvis_claude_bin", "claude") or "claude",
+            model=settings.brain_llm_model,
+            timeout_seconds=settings.brain_llm_polish_timeout_seconds,
+            semaphore_size=settings.brain_llm_semaphore_size,
+            grounding_strict=settings.brain_llm_grounding_strict,
+        )
+        return _brain_llm_service
+
     brain_key = _secret_text(settings.brain_llm_gateway_api_key)
     global_key = _secret_text(settings.llm_gateway_api_key)
 

{marvisx_cli-0.3.8b3 → marvisx_cli-0.3.8b6}/core/api/services/brain/memory_ops.py

@@ -1519,10 +1519,21 @@ def _next_action_for(op: MemoryOperation) -> ApplyNextAction:
     target_type = pw.target_type  # type: ignore[union-attr]
 
     if op.operation_type == "reinforce":
-        tool = None
-        rationale = "reinforce produces edge metric evidence only; v2 may write to graph_edge_metrics."
-        if hasattr(pw, "edge_id"):
-            args = {"edge_id": pw.edge_id, "metric_kind": pw.metric_kind, "delta": pw.delta}
+        if target_type == "none":
+            # Fase D temporal recency: bump the node's last_verified_at via the
+            # write-path tool (proposed_write is `none`; the node id rides in
+            # source_ref). Guidance-only: the operator/agent runs the tool.
+            tool = "mcp__marvis__mark_kg_verified"
+            args = {"node_id": op.source_ref}
+            rationale = (
+                "Temporal recency: this live node is aging and never verified. "
+                "Approve → mark_kg_verified stamps last_verified_at so it reads fresh."
+            )
+        else:
+            tool = None
+            rationale = "reinforce produces edge metric evidence only; v2 may write to graph_edge_metrics."
+            if hasattr(pw, "edge_id"):
+                args = {"edge_id": pw.edge_id, "metric_kind": pw.metric_kind, "delta": pw.delta}
     elif op.operation_type == "cascade_rollup":
         tool = None
         rationale = "Cascade rollup is apply-guidance-only. Operator appends body to parent context.md."