mednotes-opencode 0.1.0

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/notes/canonical_merge.py

@@ -0,0 +1,277 @@
+"""Apply process-chats canonical merges into existing Wiki notes."""
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+from mednotes.domains.wiki.capabilities.graph.coverage import validate_raw_coverage_structure
+from mednotes.domains.wiki.capabilities.markdown.markdown_query import (
+    MarkdownQueryUnavailable,
+    ensure_markdown_query_available,
+    markdown_query_blocked_payload,
+)
+from mednotes.domains.wiki.capabilities.notes.note_style.frontmatter import FrontmatterYamlUnavailable, infer_title
+from mednotes.domains.wiki.capabilities.notes.provenance import _apply_note_provenance_from_raw_files
+from mednotes.domains.wiki.capabilities.notes.raw_chats import atomic_write_text, mutate_raw_frontmatter
+from mednotes.domains.wiki.capabilities.style.style import apply_style_rewrite
+from mednotes.domains.wiki.capabilities.vocabulary.link_terms import normalize_key
+from mednotes.domains.wiki.common import MissingPathError, ValidationError, _now_iso
+from mednotes.domains.wiki.config import MedConfig, _path
+from mednotes.domains.wiki.contracts.workflow_guardrails import annotate_payload
+from mednotes.domains.wiki.flows.link.link_triggers import LINK_TRIGGER_CONTEXT_SCHEMA
+
+CANONICAL_MERGE_APPLY_SCHEMA = "medical-notes-workbench.canonical-merge-apply.v1"
+
+
+def _load_coverage_primary_raw(path: Path) -> Path:
+    if not path.exists():
+        raise MissingPathError(f"Coverage inventory not found: {path}")
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise ValidationError(f"Invalid coverage inventory JSON: {exc}") from exc
+    if not isinstance(data, dict):
+        raise ValidationError("Coverage inventory must be a JSON object")
+    raw_file = str(data.get("raw_file") or "").strip()
+    if not raw_file:
+        raise ValidationError("Coverage inventory missing raw_file")
+    return _path(raw_file)
+
+
+def _load_coverage_planned_meaning_keys(path: Path) -> set[str]:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    items = data.get("items") if isinstance(data, dict) else None
+    if not isinstance(items, list):
+        return set()
+    return {
+        normalize_key(str(item.get("staged_title") or item.get("title") or ""))
+        for item in items
+        if isinstance(item, dict) and str(item.get("action") or "") == "planned_meaning"
+    }
+
+
+def _hash_if_present(path: Path) -> str:
+    return "sha256:" + hashlib.sha256(path.read_bytes()).hexdigest() if path.exists() else ""
+
+
+def _wiki_relative_path(path: Path, config: MedConfig) -> str:
+    try:
+        return path.relative_to(config.wiki_dir).as_posix()
+    except ValueError:
+        return str(path)
+
+
+def _rollback(originals: dict[Path, str]) -> dict[str, list[str]]:
+    result = {"restored": [], "rollback_errors": []}
+    for path, text in originals.items():
+        try:
+            atomic_write_text(path, text)
+            result["restored"].append(str(path))
+        except Exception as exc:  # pragma: no cover - OS-level rollback failure
+            result["rollback_errors"].append(f"{path}: {exc}")
+    return result
+
+
+def _trigger_context(config: MedConfig, target_path: Path, *, coverage_path: Path) -> dict[str, Any]:
+    return {
+        "schema": LINK_TRIGGER_CONTEXT_SCHEMA,
+        "source_workflow": "/mednotes:process-chats",
+        "batch_id": str(coverage_path),
+        "changed_notes": [
+            {
+                "change_type": "modified",
+                "content_change": "text",
+                "path": _wiki_relative_path(target_path, config),
+                "title": target_path.stem,
+                "after_hash": _hash_if_present(target_path),
+            }
+        ],
+    }
+
+
+def _prepare_merge_content(content: str, *, content_path: Path, raw_paths: list[Path], coverage: dict[str, Any]) -> str:
+    title = infer_title(content, content_path)
+    try:
+        result = _apply_note_provenance_from_raw_files(
+            content,
+            raw_files=raw_paths,
+            title=title,
+            coverage_summary=coverage,
+        )
+    except FrontmatterYamlUnavailable as exc:
+        raise ValidationError(f"{exc.blocked_reason}: {exc.next_action}") from exc
+    except ValueError as exc:
+        raise ValidationError(f"chat_provenance_invalid: {exc}") from exc
+    return str(result["text"])
+
+
+def apply_canonical_merge(
+    config: MedConfig,
+    target_path: Path,
+    content_path: Path,
+    coverage_path: Path,
+    *,
+    dry_run: bool = False,
+    backup: bool = False,
+) -> dict[str, Any]:
+    backup = False
+    raw_file = _load_coverage_primary_raw(coverage_path)
+    if not dry_run:
+        try:
+            ensure_markdown_query_available(
+                wiki_dir=config.wiki_dir,
+                raw_dir=config.raw_dir,
+                state_dir=config.state_dir,
+            )
+        except MarkdownQueryUnavailable as exc:
+            return annotate_payload(
+                {
+                    **markdown_query_blocked_payload(
+                        phase="canonical_merge_apply",
+                        required_inputs=["target", "content", "coverage"],
+                    ),
+                    "error_context": {
+                        "blocked_reason": exc.blocked_reason,
+                        "root_cause": "markdown_query_index_unavailable",
+                        "affected_artifact": "markdown_query_index",
+                        "error_summary": str(exc),
+                        "suggested_fix": exc.next_action,
+                        "next_action": exc.next_action,
+                        "retry_scope": "setup_markdown_query_index_then_retry",
+                        "details": exc.payload,
+                    },
+                },
+                phase="canonical_merge_apply",
+                status="blocked",
+                blocked_reason=exc.blocked_reason,
+                next_action=exc.next_action,
+                required_inputs=["target", "content", "coverage"],
+                human_decision_required=False,
+            )
+    coverage = validate_raw_coverage_structure(
+        coverage_path,
+        raw_file,
+        require_triage_note_plan=True,
+    )
+    coverage_keys = _load_coverage_planned_meaning_keys(coverage_path)
+    if normalize_key(target_path.stem) not in coverage_keys:
+        raise ValidationError(
+            "Canonical merge coverage does not include the existing target title: "
+            f"{target_path.stem}"
+        )
+
+    raw_paths = [_path(path) for path in coverage["raw_files"]]
+    prepared_content = _prepare_merge_content(
+        content_path.read_text(encoding="utf-8"),
+        content_path=content_path,
+        raw_paths=raw_paths,
+        coverage=coverage,
+    )
+    preflight = apply_style_rewrite(
+        target_path,
+        content_path,
+        dry_run=True,
+        backup=False,
+        rewritten_content=prepared_content,
+    )
+    result: dict[str, Any] = {
+        "schema": CANONICAL_MERGE_APPLY_SCHEMA,
+        "phase": "canonical_merge_apply",
+        "target_path": str(target_path),
+        "content_path": str(content_path),
+        "coverage_path": str(coverage_path),
+        "dry_run": dry_run,
+        "backup": backup,
+        "coverage": coverage,
+        "validation": preflight["validation"],
+        "changed": preflight["changed"],
+        "written": False,
+        "backup_path": None,
+        "raw_updates": [],
+        "processed_raw_count": 0,
+        "link_trigger_context": None,
+    }
+    if preflight["validation"]["errors"]:
+        return annotate_payload(
+            result,
+            phase="canonical_merge_apply",
+            status="blocked",
+            blocked_reason="validation_errors",
+            next_action="Corrigir o rewrite gerado pelo architect e repetir apply-canonical-merge --dry-run.",
+            required_inputs=["target", "content", "coverage"],
+        )
+    if not preflight["changed"]:
+        return annotate_payload(
+            result,
+            phase="canonical_merge_apply",
+            status="blocked",
+            blocked_reason="no_delta_to_merge",
+            next_action="Reclassificar a unidade como not_a_note se não houver delta, ou pedir novo rewrite ao architect.",
+            required_inputs=["target", "content", "coverage"],
+        )
+    if dry_run:
+        return annotate_payload(
+            result,
+            phase="canonical_merge_apply",
+            status="ready",
+            blocked_reason="",
+            next_action="Aplicar com apply-canonical-merge; rollback fica no ponto de restauração do vault.",
+            required_inputs=["target", "content", "coverage"],
+        )
+
+    originals = {target_path: target_path.read_text(encoding="utf-8")}
+    originals.update({path: path.read_text(encoding="utf-8") for path in raw_paths})
+    try:
+        applied = apply_style_rewrite(
+            target_path,
+            content_path,
+            dry_run=False,
+            backup=backup,
+            rewritten_content=prepared_content,
+        )
+        if applied["validation"]["errors"]:
+            result["validation"] = applied["validation"]
+            return annotate_payload(
+                result,
+                phase="canonical_merge_apply",
+                status="blocked",
+                blocked_reason="validation_errors",
+                next_action="Corrigir o rewrite gerado pelo architect e repetir apply-canonical-merge --dry-run.",
+                required_inputs=["target", "content", "coverage"],
+            )
+        result["written"] = bool(applied.get("written"))
+        result["backup_path"] = applied.get("backup_path")
+        raw_updates = [
+            mutate_raw_frontmatter(
+                path,
+                {"status": "processado", "processed_at": _now_iso()},
+                backup=backup,
+            )
+            for path in raw_paths
+        ]
+    except Exception as exc:
+        rollback = _rollback(originals)
+        result["rollback"] = rollback
+        result["error"] = str(exc)
+        return annotate_payload(
+            result,
+            phase="canonical_merge_apply",
+            status="failed",
+            blocked_reason="io_error_rollback_performed",
+            next_action="Inspecionar erro de IO/rollback e repetir somente depois de liberar arquivos bloqueados.",
+            required_inputs=["target", "content", "coverage"],
+        )
+
+    result["raw_updates"] = raw_updates
+    result["processed_raw_count"] = len(raw_updates)
+    result["link_trigger_context"] = _trigger_context(config, target_path, coverage_path=coverage_path)
+    return annotate_payload(
+        result,
+        phase="canonical_merge_apply",
+        status="completed",
+        blocked_reason="",
+        next_action="Rodar linker a partir do trigger context gerado.",
+        required_inputs=["target", "content", "coverage"],
+    )

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/notes/markdown_zones.py

@@ -0,0 +1,85 @@
+"""Protected Markdown zones shared by Wiki workflows."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class MarkdownZone:
+    kind: str
+    start: int
+    end: int
+    start_line: int
+    end_line: int
+
+
+def protected_markdown_zones(text: str) -> list[MarkdownZone]:
+    zones: list[MarkdownZone] = []
+    lines = text.splitlines(keepends=True)
+    offset = 0
+    idx = 0
+    in_math = False
+    math_start = 0
+    math_start_line = 1
+    while idx < len(lines):
+        line = lines[idx]
+        stripped = line.strip().lower()
+        if stripped.startswith(("```", "~~~")):
+            marker = stripped[:3]
+            info = stripped[3:].strip()
+            kind = "fenced_mermaid" if info.startswith("mermaid") else "fenced_code"
+            start = offset
+            start_line = idx + 1
+            offset += len(line)
+            idx += 1
+            while idx < len(lines):
+                current = lines[idx]
+                current_stripped = current.strip().lower()
+                offset += len(current)
+                idx += 1
+                if current_stripped.startswith(marker):
+                    break
+            zones.append(MarkdownZone(kind=kind, start=start, end=offset, start_line=start_line, end_line=idx))
+            continue
+        if stripped == "$$":
+            if not in_math:
+                in_math = True
+                math_start = offset
+                math_start_line = idx + 1
+            else:
+                zones.append(
+                    MarkdownZone(
+                        kind="display_math",
+                        start=math_start,
+                        end=offset + len(line),
+                        start_line=math_start_line,
+                        end_line=idx + 1,
+                    )
+                )
+                in_math = False
+        offset += len(line)
+        idx += 1
+    if in_math:
+        zones.append(
+            MarkdownZone(
+                kind="display_math",
+                start=math_start,
+                end=len(text),
+                start_line=math_start_line,
+                end_line=len(lines),
+            )
+        )
+    return zones
+
+
+def blank_protected_markdown(text: str) -> str:
+    chars = list(text)
+    for zone in protected_markdown_zones(text):
+        for idx in range(zone.start, zone.end):
+            if chars[idx] != "\n":
+                chars[idx] = " "
+    return "".join(chars)
+
+
+def is_protected_markdown_position(text: str, position: int) -> bool:
+    return any(zone.start <= position < zone.end for zone in protected_markdown_zones(text))

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/notes/meaning_planner.py

@@ -0,0 +1,307 @@
+"""Deterministic planner for triage-note-plan.v2 meaning work items."""
+from __future__ import annotations
+
+import re
+import sqlite3
+import unicodedata
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+from mednotes.domains.wiki.capabilities.notes.note_plan import (
+    PLANNED_MEANING_ACTION,
+    TRIAGE_NOTE_PLAN_V2_SCHEMA,
+    normalize_triage_note_plan_v2,
+)
+from mednotes.domains.wiki.capabilities.vocabulary.vocabulary_map import meaning_id_for
+from mednotes.domains.wiki.common import SUBAGENT_PLAN_SCHEMA, ValidationError
+from mednotes.domains.wiki.config import MedConfig
+from mednotes.domains.wiki.contracts.workflow_outcomes import (
+    DecisionEvidence,
+    RejectedAutomation,
+    WorkflowDecision,
+    attach_human_decision_packet,
+)
+from mednotes.kernel.base import JsonObject
+
+
+@dataclass(frozen=True)
+class MeaningClaim:
+    label: str
+    scope: str
+    boundaries: tuple[str, ...]
+    kind: str
+    evidence_summary: str
+    id: str = ""
+
+
+@dataclass(frozen=True)
+class MeaningWorkItem:
+    work_id: str
+    action: str
+    target_kind: str
+    raw_file: str
+    note_plan_item_id: str
+    meaning_claim: MeaningClaim
+    target_path: str = ""
+
+
+def plan_meaning_work_items(
+    config: MedConfig,
+    note_plan: dict[str, Any],
+    *,
+    raw_file: Path,
+    temp_root: Path,
+    agent: str = "med-knowledge-architect",
+) -> dict[str, Any]:
+    try:
+        normalized = (
+            normalize_triage_note_plan_v2(note_plan, raw_file)
+            if note_plan.get("schema") == TRIAGE_NOTE_PLAN_V2_SCHEMA
+            else note_plan
+        )
+    except ValidationError as exc:
+        return _blocked_payload(
+            blocked_reason="meaning_claim_invalid",
+            message=str(exc),
+            raw_file=raw_file,
+            agent=agent,
+        )
+    if normalized.get("schema") != TRIAGE_NOTE_PLAN_V2_SCHEMA:
+        return _blocked_payload(
+            blocked_reason="note_plan_v2_required",
+            message="meaning planner requires triage-note-plan.v2",
+            raw_file=raw_file,
+            agent=agent,
+        )
+
+    work_items: list[dict[str, Any]] = []
+    blocked_items: list[JsonObject] = []
+    for index, item in enumerate(normalized.get("items", []), start=1):
+        if item.get("action") != PLANNED_MEANING_ACTION:
+            continue
+        try:
+            claim = _meaning_claim(item.get("meaning_claim"))
+        except ValidationError as exc:
+            blocked_items.append(
+                _blocked_item(
+                    raw_file=raw_file,
+                    note_plan_item_id=str(item.get("id") or f"M{index:03d}"),
+                    blocked_reason="meaning_claim_invalid",
+                    message=str(exc),
+                )
+            )
+            continue
+        matches = _canonical_matches(config, _claim_id(claim))
+        if len(matches) > 1:
+            blocked_item = {
+                **_blocked_item(
+                    raw_file=raw_file,
+                    note_plan_item_id=str(item.get("id") or f"M{index:03d}"),
+                    blocked_reason="human_decision_required.ambiguous_canonical_target",
+                    message="More than one active canonical note is linked to this meaning_id.",
+                ),
+                "meaning_claim": asdict(claim),
+                "candidate_targets": matches,
+            }
+            blocked_items.append(
+                attach_human_decision_packet(
+                    blocked_item,
+                    packet=_ambiguous_canonical_target_packet(
+                        claim=claim,
+                        matches=matches,
+                    ),
+                )
+            )
+            continue
+        if matches:
+            action = "rewrite_existing_note"
+            target_kind = "existing_wiki_note"
+            target_path = str(config.wiki_dir / matches[0]["path"])
+        else:
+            action = "create_new_note"
+            target_kind = "new_wiki_note"
+            target_path = ""
+        work_item = MeaningWorkItem(
+            work_id=f"meaning-{index:03d}-{_slug(claim.label)}",
+            action=action,
+            target_kind=target_kind,
+            raw_file=str(raw_file),
+            note_plan_item_id=str(item.get("id") or f"M{index:03d}"),
+            meaning_claim=claim,
+            target_path=target_path,
+        )
+        payload = asdict(work_item)
+        payload["agent"] = agent
+        payload["item_type"] = "meaning_work_item"
+        payload["launchable"] = True
+        payload["owner_key"] = target_path or f"meaning:{_claim_id(claim)}"
+        payload["temp_dir"] = str(temp_root / payload["work_id"])
+        payload["temp_output"] = str(temp_root / payload["work_id"] / f"{_slug(claim.label)}.md")
+        work_items.append(payload)
+
+    status = "blocked" if blocked_items else "ready"
+    return {
+        "schema": SUBAGENT_PLAN_SCHEMA,
+        "phase": "meaning-planner",
+        "agent": agent,
+        "status": status,
+        "blocked_reason": "preconditions_failed" if blocked_items else "",
+        "raw_file": str(raw_file),
+        "item_count": len(work_items),
+        "blocked_item_count": len(blocked_items),
+        "work_items": work_items,
+        "blocked_items": blocked_items,
+        "next_action": "" if not blocked_items else "Corrigir meaning_claim ou escolher alvo canônico antes do architect.",
+    }
+
+
+def _meaning_claim(value: Any) -> MeaningClaim:
+    if not isinstance(value, dict):
+        raise ValidationError("meaning_claim missing")
+    missing = [
+        key
+        for key in ("label", "scope", "boundaries", "kind", "evidence_summary")
+        if key != "boundaries" and not str(value.get(key) or "").strip()
+    ]
+    boundaries = value.get("boundaries")
+    if not isinstance(boundaries, list):
+        missing.append("boundaries")
+    if missing:
+        raise ValidationError(f"meaning_claim missing required fields: {', '.join(missing)}")
+    assert isinstance(boundaries, list)
+    boundaries_list = boundaries
+    return MeaningClaim(
+        label=str(value["label"]).strip(),
+        scope=str(value["scope"]).strip(),
+        boundaries=tuple(str(item).strip() for item in boundaries_list if str(item).strip()),
+        kind=str(value["kind"]).strip(),
+        evidence_summary=str(value["evidence_summary"]).strip(),
+        id=str(value.get("id") or value.get("meaning_id") or "").strip(),
+    )
+
+
+def _claim_id(claim: MeaningClaim) -> str:
+    return claim.id or meaning_id_for(claim.label)
+
+
+def _canonical_matches(config: MedConfig, meaning_id: str) -> list[dict[str, str]]:
+    db_path = config.vocabulary_db_path
+    if db_path is None or not db_path.exists():
+        return []
+    with sqlite3.connect(db_path) as conn:
+        conn.row_factory = sqlite3.Row
+        rows = conn.execute(
+            """
+            SELECT n.path, n.title, l.confidence
+            FROM meaning_note_links l
+            JOIN meanings m ON m.id = l.meaning_id AND m.status = 'active'
+            JOIN notes n ON n.id = l.note_id AND n.status = 'active'
+            WHERE l.meaning_id = ?
+              AND l.role = 'canonical'
+              AND l.status = 'active'
+            ORDER BY l.confidence DESC, n.path ASC
+            """,
+            (meaning_id,),
+        ).fetchall()
+    return [
+        {
+            "path": str(row["path"]),
+            "title": str(row["title"]),
+            "confidence": str(row["confidence"]),
+        }
+        for row in rows
+    ]
+
+
+def _ambiguous_canonical_target_packet(
+    *,
+    claim: MeaningClaim,
+    matches: list[dict[str, str]],
+) -> dict[str, Any]:
+    options = [
+        {
+            "id": f"use_{idx}",
+            "label": match["path"],
+            "value": match["path"],
+            "consequence": "O architect reescreve esse alvo canônico com o delta do raw chat.",
+        }
+        for idx, match in enumerate(matches, start=1)
+    ]
+    decision = WorkflowDecision(
+        kind="ask_human",
+        phase="meaning-planner",
+        reason_code="human_decision_required.ambiguous_canonical_target",
+        public_summary=f"Qual nota canônica deve receber '{claim.label}'?",
+        developer_summary="More than one active canonical note is linked to this meaning_id.",
+        evidence=[
+            DecisionEvidence(
+                summary=f"'{claim.label}' possui múltiplos alvos canônicos ativos.",
+                technical_code="human_decision_required.ambiguous_canonical_target",
+                source="meaning-planner",
+                candidates=[{"meaning_claim": asdict(claim), "candidate_targets": matches}],
+                risk="Escolha automática pode reescrever a nota canônica errada.",
+            )
+        ],
+        rejected_automations=[
+            RejectedAutomation(
+                kind="auto_fix",
+                reason_code="ambiguous_canonical_target",
+                reason="Nao ha alvo canonico unico para corrigir automaticamente.",
+            ),
+            RejectedAutomation(
+                kind="auto_defer",
+                reason_code="blocks_architect",
+                reason="Pular a escolha impediria cobertura correta do raw chat.",
+            ),
+            RejectedAutomation(
+                kind="auto_plan",
+                reason_code="plan_needs_canonical_target",
+                reason="O plano precisa de um alvo canonico antes de lancar o architect.",
+            ),
+        ],
+        next_action="Registrar a escolha e reexecutar plan-subagents --phase architect.",
+        resume_action="Registrar a escolha e reexecutar plan-subagents --phase architect.",
+        recommended_option_id=str(options[0]["id"]),
+        options=options,
+    )
+    packet = decision.to_human_decision_packet()
+    packet["kind"] = "ambiguous_canonical_target"
+    packet["type"] = "ambiguous_canonical_target"
+    return packet
+
+
+def _blocked_item(*, raw_file: Path, note_plan_item_id: str, blocked_reason: str, message: str) -> JsonObject:
+    return {
+        "work_id": f"meaning-blocked-{_slug(note_plan_item_id)}",
+        "item_type": "meaning_work_item",
+        "raw_file": str(raw_file),
+        "note_plan_item_id": note_plan_item_id,
+        "blocked_reason": blocked_reason,
+        "reason": message,
+        "launchable": False,
+        "write_policy": "no_temp_note",
+    }
+
+
+def _blocked_payload(*, blocked_reason: str, message: str, raw_file: Path, agent: str) -> JsonObject:
+    item = _blocked_item(raw_file=raw_file, note_plan_item_id="", blocked_reason=blocked_reason, message=message)
+    return {
+        "schema": SUBAGENT_PLAN_SCHEMA,
+        "phase": "meaning-planner",
+        "agent": agent,
+        "status": "blocked",
+        "blocked_reason": blocked_reason,
+        "raw_file": str(raw_file),
+        "item_count": 0,
+        "blocked_item_count": 1,
+        "work_items": [],
+        "blocked_items": [item],
+        "next_action": "Corrigir triage-note-plan.v2 antes de lançar architect.",
+    }
+
+
+def _slug(value: str) -> str:
+    normalized = unicodedata.normalize("NFKD", value)
+    ascii_text = "".join(char for char in normalized if not unicodedata.combining(char))
+    return re.sub(r"[^a-zA-Z0-9._-]+", "-", ascii_text).strip("-._").lower() or "meaning"