@junghanacs/entwurf 0.16.0 → 0.16.1

package/scripts/mutants/acp-prompt-lifecycle.json

@@ -54,8 +54,8 @@
 			"claim": "REUSE-CARRIES-CHILD-DIAGNOSTICS",
 			"title": "the reuse path drops the child's stderr tail again — exactly the live sonnet failure that showed only \"ACP connection closed\"",
 			"subject": "pi-extensions/lib/acp/backend.ts",
-			"find": ["\t\t\tfinishError(err, aborted, session.stderrTail, lifecycle);"],
-			"replace": ["\t\t\tfinishError(err, aborted, undefined, lifecycle);"],
+			"find": ["\t\t\tfinishError(err, aborted, session.stderrTail, lifecycle, session.launchObservation);"],
+			"replace": ["\t\t\tfinishError(err, aborted, undefined, lifecycle, session.launchObservation);"],
 			"gate": ["bash", "run.sh", "check-acp-prompt-lifecycle"],
 			"timeoutSeconds": 180,
 			"signature": "[QK:REUSE-CARRIES-CHILD-DIAGNOSTICS]",
@@ -117,6 +117,71 @@
 			"timeoutSeconds": 180,
 			"signature": "[QK:CHILD-END-SILENCE-BOUNDED]",
 			"signatureSource": "scripts/check-acp-prompt-lifecycle.ts"
+		},
+		{
+			"claim": "LAUNCH-SIGNAL-EVIDENCE-STRUCTURED",
+			"title": "the caught-signal observation is dropped from the report — an externally killed child again reads as a clean vendor exit, the exact ambiguity #72 cost three diagnosis passes",
+			"subject": "pi-extensions/lib/acp/backend.ts",
+			"find": ["\t\tconst diagnosed = observed ? `${withLifecycle}\\n${observed}` : withLifecycle;"],
+			"replace": ["\t\tconst diagnosed = withLifecycle;"],
+			"gate": ["bash", "run.sh", "check-acp-prompt-lifecycle"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:LAUNCH-SIGNAL-EVIDENCE-STRUCTURED]",
+			"signatureSource": "scripts/check-acp-prompt-lifecycle.ts"
+		},
+		{
+			"claim": "LAUNCH-FRAME-NOT-IN-TAIL",
+			"title": "the launcher's control frame is echoed into the vendor stderr tail — entwurf's own fact is laundered back into vendor evidence",
+			"subject": "pi-extensions/lib/acp/backend.ts",
+			"find": ["\t\t\tspawned.stderr.on(\"data\", (c: Buffer) => consumeStderr.write(c.toString()));"],
+			"replace": [
+				"\t\t\tspawned.stderr.on(\"data\", (c: Buffer) => {",
+				"\t\t\t\tconsumeStderr.write(c.toString());",
+				"\t\t\t\tstderrTail.push(c.toString());",
+				"\t\t\t});"
+			],
+			"gate": ["bash", "run.sh", "check-acp-prompt-lifecycle"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:LAUNCH-FRAME-NOT-IN-TAIL]",
+			"signatureSource": "scripts/check-acp-prompt-lifecycle.ts"
+		},
+		{
+			"claim": "LAUNCH-SIGNAL-EXACT-FRAME-ONLY",
+			"title": "the frame is matched by prefix without its fixed enum — vendor prose can forge an entwurf-owned observation",
+			"subject": "pi-extensions/lib/acp/backend.ts",
+			"find": [
+				"\t\t\t\tif (",
+				"\t\t\t\t\tline.startsWith(LAUNCH_SIGNAL_FRAME_PREFIX) &&",
+				"\t\t\t\t\tLAUNCH_SIGNAL_FRAME_VALUES.has(line.slice(LAUNCH_SIGNAL_FRAME_PREFIX.length))",
+				"\t\t\t\t) {"
+			],
+			"replace": ["\t\t\t\tif (line.includes(LAUNCH_SIGNAL_FRAME_PREFIX)) {"],
+			"gate": ["bash", "run.sh", "check-acp-prompt-lifecycle"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:LAUNCH-SIGNAL-EXACT-FRAME-ONLY]",
+			"signatureSource": "scripts/check-acp-prompt-lifecycle.ts"
+		},
+		{
+			"claim": "STDERR-TAIL-FLUSHES-PARTIAL-LINE",
+			"title": "the line buffer never flushes its unterminated remainder — a child that dies mid-write loses the dying words the stderr tail exists to carry",
+			"subject": "pi-extensions/lib/acp/backend.ts",
+			"find": ["\t\t\tspawned.stderr.once?.(\"close\", () => consumeStderr.flush());"],
+			"replace": ["\t\t\tvoid consumeStderr;"],
+			"gate": ["bash", "run.sh", "check-acp-prompt-lifecycle"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:STDERR-TAIL-FLUSHES-PARTIAL-LINE]",
+			"signatureSource": "scripts/check-acp-prompt-lifecycle.ts"
+		},
+		{
+			"claim": "LAUNCH-FRAME-SPANS-CHUNKS",
+			"title": "the frame is matched per read instead of per line — a frame split across a chunk boundary is missed, and the external kill goes unreported exactly as it did in the field",
+			"subject": "pi-extensions/lib/acp/backend.ts",
+			"find": ["\t\t\theld += chunk;"],
+			"replace": ["\t\t\theld = chunk;"],
+			"gate": ["bash", "run.sh", "check-acp-prompt-lifecycle"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:LAUNCH-FRAME-SPANS-CHUNKS]",
+			"signatureSource": "scripts/check-acp-prompt-lifecycle.ts"
 		}
 	]
 }

package/scripts/mutants/copilot-birth.json

@@ -196,12 +196,10 @@
 		},
 		{
 			"claim": "COPILOT-MALFORMED-ROW-NOT-ABSENT",
-			"title": "a truncated/garbled exact plugin row falls through the parser and rounds to ABSENT, which the inverse reads as retry-safe absence and continues past — the exact fall-through B reproduced (`(v0.1` with no closing paren) against 47a5ae3 (#86 C3a corrective amendment, B defect 3)",
+			"title": "a truncated/garbled exact plugin row falls through the parser and rounds to ABSENT, which the inverse reads as retry-safe absence and continues past — the exact fall-through B reproduced (`(v0.1` with no closing paren) against 47a5ae3 (#86 C3a corrective amendment, B defect 3). The parse became a regex when the 1.0.81 state token was admitted; the fall-through must stay closed on either spelling.",
 			"subject": "scripts/copilot-bridge-oracle.sh",
-			"find": [
-				"    if not (rest.startswith(\"(v\") and rest.endswith(\")\")):\n        print(f\"malformed exact row for {qualified}: {row!r} does not parse as '<qualified> (v<version>)'\", file=sys.stderr)\n        sys.exit(1)"
-			],
-			"replace": ["    if not (rest.startswith(\"(v\") and rest.endswith(\")\")):\n        continue"],
+			"find": ["    match = ROW_TAIL.fullmatch(rest)\n    if match is None:"],
+			"replace": ["    match = ROW_TAIL.fullmatch(rest)\n    if match is None:\n        continue\n    if False:"],
 			"gate": ["bash", "run.sh", "check-copilot-birth-hook"],
 			"timeoutSeconds": 300,
 			"signature": "[QK:COPILOT-MALFORMED-ROW-NOT-ABSENT]",

package/scripts/mutants/pack-install.json

@@ -6,8 +6,8 @@
 			"claim": "PACK-INSTALL-PIN-MATCHER-BOUNDED",
 			"title": "the pin-leak matcher loses its version boundary and blesses substring lookalikes — @0.84.30 reads as the pinned 0.84.3 and the gate announces a verified tree it never verified (independent review, 2026-08-25)",
 			"subject": "run.sh",
-			"find": ["  grep '^@earendil-works+pi-' | grep -Ev '@0\\.84\\.3(_|$)' || true"],
-			"replace": ["  grep '^@earendil-works+pi-' | grep -v '@0\\.84\\.3' || true"],
+			"find": ["  grep '^@earendil-works+pi-' | grep -Ev '@0\\.84\\.4(_|$)' || true"],
+			"replace": ["  grep '^@earendil-works+pi-' | grep -v '@0\\.84\\.4' || true"],
 			"gate": ["bash", "run.sh", "check-pack-pin-matcher"],
 			"timeoutSeconds": 120,
 			"signature": "[QK:PACK-INSTALL-PIN-MATCHER-BOUNDED]",

package/scripts/mutants/setup-verdict.json

@@ -143,6 +143,41 @@
 			"timeoutSeconds": 600,
 			"signature": "[QK:SETUP-AGY-COSMETIC-RETURN]",
 			"signatureSource": "scripts/smoke-agy-install-state.sh"
+		},
+		{
+			"claim": "SETUP-OMP-ABSENT-SKIP",
+			"title": "an absent omp is composed anyway instead of taking the zero-state SKIP branch, so setup writes omp units onto a host that never installed omp",
+			"subject": "run.sh",
+			"find": [
+				"  if ! command -v \"${OMP_BIN:-omp}\" >/dev/null 2>&1; then\n    setup_result omp SKIP \"omp not on PATH — zero OMP wiring written\""
+			],
+			"replace": ["  if false; then\n    setup_result omp SKIP \"omp not on PATH — zero OMP wiring written\""],
+			"gate": ["bash", "scripts/check-setup-qualification.sh"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:SETUP-OMP-ABSENT-SKIP]",
+			"signatureSource": "scripts/check-setup-qualification.sh"
+		},
+		{
+			"claim": "SETUP-OMP-INDEPENDENT",
+			"title": "the omp units stop being composed at all — the exact v0.16.0 shape: every installer exists, setup never reaches them, and the summary still computes green",
+			"subject": "run.sh",
+			"find": ["    omp_rc=0; (cd \"$REPO_DIR\" && bash scripts/omp-bridge-install.sh) || omp_rc=$?"],
+			"replace": ["    omp_rc=0"],
+			"gate": ["bash", "scripts/check-setup-qualification.sh"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:SETUP-OMP-INDEPENDENT]",
+			"signatureSource": "scripts/check-setup-qualification.sh"
+		},
+		{
+			"claim": "SETUP-OMP-CONFIG-NO-OVERWRITE",
+			"title": "the tools.xdev writer overwrites an EXPLICIT operator `xdev: true` instead of refusing it by name, so entwurf silently reverses a decision the operator wrote down",
+			"subject": "scripts/omp-config-xdev.py",
+			"find": ["        if existing is not None:"],
+			"replace": ["        if False:"],
+			"gate": ["bash", "scripts/check-setup-qualification.sh"],
+			"timeoutSeconds": 180,
+			"signature": "[QK:SETUP-OMP-CONFIG-NO-OVERWRITE]",
+			"signatureSource": "scripts/check-setup-qualification.sh"
 		}
 	]
 }

package/scripts/omp-config-xdev.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""Write the ONE operator setting omp's tool hand requires: ``tools.xdev: false``.
+
+stdlib only. This is the WRITER half of the runtime cell ``omp-tool-surface.py``
+already reads and ``doctor-omp-mcp`` already judges. Until it existed the setting
+was documentation — `docs/setup-clean-host.md` §4b told the operator to hand-edit
+`config.yml`, and a host that skipped it looked green everywhere except the one
+place it mattered: the doorbell announced ``mcp__entwurf_bridge_entwurf_v`` while
+the vendor had wrapped every MCP tool behind ``xd://`` and the model could not
+call it (measured, omp 18.0.0).
+
+Ownership, in the same shape as every other entwurf writer:
+
+* The config file is the VENDOR's. We add exactly one key and we record exactly
+  what we added, so the inverse can take back our bytes and nothing else.
+* ``xdev: true`` written EXPLICITLY by the operator is a decision, not drift. We
+  refuse it by name instead of overwriting — setup reports a FAIL the operator
+  resolves, which is the honest branch when two authorities disagree.
+* A config we cannot parse is refused, never rewritten. A writer that edits a
+  file it cannot read is how a config gets corrupted.
+
+Exit codes: 0 ok · 2 nothing to do (uninstall, no state) · 3 refused (symlink) ·
+4 unreadable/invalid · 5 refused (operator's explicit xdev: true) · 6 refused
+(the file changed under us since install).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+import time
+
+STATE_SCHEMA = 1
+TRUE_WORDS = {"true", "yes", "on", "y"}
+FALSE_WORDS = {"false", "no", "off", "n"}
+
+
+def die(code: int, message: str) -> None:
+    sys.stderr.write(message.rstrip("\n") + "\n")
+    raise SystemExit(code)
+
+
+def sha256(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def strip_comment(raw: str) -> str:
+    """Drop a trailing `#` comment outside quotes — the reader's rule, kept in sync."""
+    in_single = in_double = escaped = False
+    for index, char in enumerate(raw):
+        if escaped:
+            escaped = False
+            continue
+        if char == "\\" and in_double:
+            escaped = True
+            continue
+        if char == "'" and not in_double:
+            in_single = not in_single
+            continue
+        if char == '"' and not in_single:
+            in_double = not in_double
+            continue
+        if char == "#" and not in_single and not in_double:
+            return raw[:index].rstrip()
+    return raw.rstrip()
+
+
+def indent_of(line: str) -> int:
+    body = strip_comment(line)
+    return len(body) - len(body.lstrip(" "))
+
+
+def split_key(line: str) -> str | None:
+    """The key of a `key: value` line, or None when the line is not a mapping entry."""
+    body = strip_comment(line).strip()
+    if not body or body.startswith("- ") or body.startswith("#"):
+        return None
+    in_single = in_double = False
+    for index, char in enumerate(body):
+        if char == "'" and not in_double:
+            in_single = not in_single
+            continue
+        if char == '"' and not in_single:
+            in_double = not in_double
+            continue
+        if char == ":" and not in_single and not in_double:
+            key = body[:index].strip()
+            if (len(key) >= 2) and (key[0] == key[-1] == '"' or key[0] == key[-1] == "'"):
+                key = key[1:-1]
+            return key or None
+    return None
+
+
+def value_of(line: str) -> str:
+    body = strip_comment(line).strip()
+    _, _, rest = body.partition(":")
+    return rest.strip()
+
+
+def scalar_bool(raw: str) -> bool | None:
+    text = raw.strip()
+    if (len(text) >= 2) and (text[0] == text[-1] == '"' or text[0] == text[-1] == "'"):
+        text = text[1:-1]
+    folded = text.casefold()
+    if folded in TRUE_WORDS:
+        return True
+    if folded in FALSE_WORDS:
+        return False
+    return None
+
+
+def find_tools_block(lines: list[str]) -> tuple[int, int, int] | None:
+    """(header index, first child index, child indent) for the TOP-LEVEL `tools:` key."""
+    for index, line in enumerate(lines):
+        if not strip_comment(line).strip():
+            continue
+        if indent_of(line) != 0:
+            continue
+        if split_key(line) != "tools":
+            continue
+        end = index + 1
+        child_indent = -1
+        while end < len(lines):
+            if not strip_comment(lines[end]).strip():
+                end += 1
+                continue
+            if indent_of(lines[end]) == 0:
+                break
+            if child_indent < 0:
+                child_indent = indent_of(lines[end])
+            end += 1
+        return index, end, (child_indent if child_indent > 0 else 2)
+    return None
+
+
+def read_config(path: str) -> list[str]:
+    with open(path, "r", encoding="utf-8") as handle:
+        return handle.read().splitlines()
+
+
+def write_config(path: str, lines: list[str]) -> str:
+    text = "\n".join(lines) + "\n"
+    parent = os.path.dirname(path) or "."
+    os.makedirs(parent, exist_ok=True)
+    tmp = f"{path}.entwurf-tmp"
+    with open(tmp, "w", encoding="utf-8") as handle:
+        handle.write(text)
+    os.replace(tmp, path)
+    return text
+
+
+def write_state(state_file: str, payload: dict[str, object]) -> None:
+    os.makedirs(os.path.dirname(state_file) or ".", exist_ok=True)
+    tmp = f"{state_file}.tmp"
+    with open(tmp, "w", encoding="utf-8") as handle:
+        json.dump(payload, handle, indent=2, sort_keys=True)
+        handle.write("\n")
+    os.replace(tmp, state_file)
+
+
+def do_install(config_path: str, state_file: str) -> None:
+    if os.path.islink(config_path):
+        die(3, f"refusing: {config_path} is a symlink — entwurf never writes through a link")
+    existed = os.path.exists(config_path)
+    if existed and not os.path.isfile(config_path):
+        die(4, f"refusing: {config_path} exists and is not a regular file")
+
+    lines = read_config(config_path) if existed else []
+    block = find_tools_block(lines)
+    inserted: list[str] = []
+    action: str
+
+    if block is None:
+        # No `tools:` at all — append the whole two-line section. The vendor's own
+        # writer emits `key: ` with a trailing space, so the file stays uniform.
+        if lines and strip_comment(lines[-1]).strip() == "":
+            lines = lines[:-1]
+        inserted = ["tools: ", "  xdev: false"]
+        lines.extend(inserted)
+        action = "created-file" if not existed else "appended-tools-block"
+    else:
+        header, end, child_indent = block
+        existing = None
+        for index in range(header + 1, end):
+            if indent_of(lines[index]) == child_indent and split_key(lines[index]) == "xdev":
+                existing = index
+                break
+        if existing is not None:
+            current = scalar_bool(value_of(lines[existing]))
+            if current is False:
+                write_state(
+                    state_file,
+                    {
+                        "schemaVersion": STATE_SCHEMA,
+                        "configPath": os.path.abspath(config_path),
+                        "fileExistedBefore": True,
+                        "action": "already-false",
+                        "insertedLines": [],
+                        "postimageSha256": sha256("\n".join(lines) + "\n"),
+                        "installedAt": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
+                    },
+                )
+                print(f"already-set {config_path} (tools.xdev is false — nothing written)")
+                return
+            if current is True:
+                die(
+                    5,
+                    f"refusing: {config_path} sets tools.xdev: true EXPLICITLY (line {existing + 1}). "
+                    "That is the operator's decision, not drift, so entwurf will not overwrite it. "
+                    "Entwurf's MCP tools are unreachable from omp while xdev is on and no "
+                    "xdevInlineDevices glob covers them — set it to false yourself, or accept that "
+                    "the omp citizen cannot call entwurf tools.",
+                )
+            die(4, f"refusing: {config_path} line {existing + 1} sets tools.xdev to a value this reader cannot classify")
+        inserted = [" " * child_indent + "xdev: false"]
+        lines[end:end] = inserted
+        action = "inserted-xdev-key"
+
+    text = write_config(config_path, lines)
+    write_state(
+        state_file,
+        {
+            "schemaVersion": STATE_SCHEMA,
+            "configPath": os.path.abspath(config_path),
+            "fileExistedBefore": existed,
+            "action": action,
+            "insertedLines": inserted,
+            "postimageSha256": sha256(text),
+            "installedAt": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
+        },
+    )
+    print(f"{action} {config_path} (tools.xdev: false)")
+
+
+def do_uninstall(state_file: str) -> None:
+    if not os.path.exists(state_file):
+        die(2, f"no install-state at {state_file} — entwurf never wrote this setting on this host")
+    try:
+        with open(state_file, "r", encoding="utf-8") as handle:
+            state = json.load(handle)
+    except (OSError, ValueError):
+        die(4, f"install-state at {state_file} is unreadable — refusing to guess what to take back")
+    if not isinstance(state, dict) or state.get("schemaVersion") != STATE_SCHEMA:
+        die(4, f"install-state at {state_file} is not schemaVersion {STATE_SCHEMA} — refusing")
+
+    config_path = state.get("configPath")
+    action = state.get("action")
+    inserted = state.get("insertedLines")
+    if not isinstance(config_path, str) or not isinstance(inserted, list):
+        die(4, f"install-state at {state_file} is malformed — refusing")
+
+    if action == "already-false":
+        os.remove(state_file)
+        print(f"nothing to take back ({config_path} already had tools.xdev: false); state cleared")
+        return
+
+    if os.path.islink(config_path):
+        die(3, f"refusing: {config_path} is now a symlink — entwurf never writes through a link")
+    if not os.path.exists(config_path):
+        os.remove(state_file)
+        print(f"{config_path} is already gone; state cleared")
+        return
+
+    with open(config_path, "r", encoding="utf-8") as handle:
+        current = handle.read()
+    if sha256(current) != state.get("postimageSha256"):
+        die(
+            6,
+            f"refusing: {config_path} changed since entwurf wrote it. Remove the tools.xdev line "
+            "yourself if you want it gone — a blind edit here would take back somebody else's bytes.",
+        )
+
+    if action == "created-file":
+        os.remove(config_path)
+        os.remove(state_file)
+        print(f"removed {config_path} (entwurf created it); state cleared")
+        return
+
+    lines = current.splitlines()
+    for line in reversed(inserted):
+        if line in lines:
+            lines.remove(line)
+        else:
+            die(6, f"refusing: the line {line!r} entwurf added is no longer in {config_path}")
+    write_config(config_path, lines)
+    os.remove(state_file)
+    print(f"took back {len(inserted)} line(s) from {config_path}; state cleared")
+
+
+def main(argv: list[str]) -> None:
+    if len(argv) < 2:
+        die(5, "usage: omp-config-xdev.py install <config-path> <state-file> | uninstall <state-file>")
+    verb = argv[1]
+    if verb == "install":
+        if len(argv) != 4:
+            die(5, "usage: omp-config-xdev.py install <config-path> <state-file>")
+        do_install(argv[2], argv[3])
+        return
+    if verb == "uninstall":
+        if len(argv) != 3:
+            die(5, "usage: omp-config-xdev.py uninstall <state-file>")
+        do_uninstall(argv[2])
+        return
+    die(5, f"unknown verb {verb!r} — install | uninstall")
+
+
+if __name__ == "__main__":
+    main(sys.argv)

package/scripts/omp-config-xdev.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+# OMP operator-setting adapter (`tools.xdev: false`) — the WRITER for the runtime cell
+# `doctor-omp-mcp` already judges and `omp-tool-surface.py` already reads.
+#
+# Separate surface from the MCP hand on purpose: registering the server is TOOLS, and
+# `tools.xdev` decides whether those registered tools are REACHABLE at all. omp's default
+# (`xdev: true`, no inline allowlist) wraps every MCP tool behind `xd://`, so a host with a
+# perfect mcp.json still announces a doorbell tool the model cannot call. Until this adapter
+# existed the fix was a documented hand-edit, which is exactly the kind of step a one-command
+# setup is supposed to end.
+#
+# Target confinement follows the MCP hand's rule (#87 D1): the file is exactly
+# `<resolved omp agent dir>/config.yml`, never a configurable path. `ENTWURF_OMP_AGENT_DIR`
+# moves the agent dir and the target follows by construction.
+set -euo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CONFIG_PY="$HERE/omp-config-xdev.py"
+STATE_DIR="${XDG_DATA_HOME:-$HOME/.local/share}/entwurf/omp-config"
+STATE_FILE="$STATE_DIR/install-state.json"
+
+log() { printf '%s\n' "$*"; }
+fail() { printf 'FAIL: %s\n' "$*" >&2; exit 1; }
+
+# shellcheck source=scripts/omp-bridge-oracle.sh
+. "$HERE/omp-bridge-oracle.sh"
+
+AGENT_DIR="$(omp_agent_dir)" || fail "the omp agent directory this host reads is ambiguous (see above) — refusing to write a config file omp may never read."
+CONFIG="$AGENT_DIR/config.yml"
+
+do_install() {
+	log "[omp-config install]"
+	log "  target:  $CONFIG"
+	log "  setting: tools.xdev: false"
+	log "  state:   $STATE_FILE"
+	local out rc
+	set +e
+	out="$(python3 "$CONFIG_PY" install "$CONFIG" "$STATE_FILE" 2>&1)"
+	rc=$?
+	set -e
+	case "$rc" in
+		0) log "  ok: $out" ;;
+		3) fail "refused (symlink) — $out" ;;
+		4) fail "unreadable config — $out" ;;
+		5) fail "refused (the operator set tools.xdev: true explicitly) — $out" ;;
+		*) fail "install error (rc=$rc) — $out" ;;
+	esac
+	log "  installed. The runtime axis is verified by: ./run.sh doctor-omp-mcp"
+	log "  NOTE: an omp session that is ALREADY OPEN keeps the tool surface it started with;"
+	log "  restart it for the top-level tools to appear."
+}
+
+do_uninstall() {
+	log "[omp-config uninstall]"
+	local out rc
+	set +e
+	out="$(python3 "$CONFIG_PY" uninstall "$STATE_FILE" 2>&1)"
+	rc=$?
+	set -e
+	case "$rc" in
+		0) log "  ok: $out" ;;
+		2) log "  note: $out" ;;
+		3) fail "refused (symlink) — $out" ;;
+		4) fail "invalid state — $out" ;;
+		6) fail "refused (the config changed since install) — $out" ;;
+		*) fail "uninstall error (rc=$rc) — $out" ;;
+	esac
+}
+
+case "${1:-}" in
+	install) do_install ;;
+	uninstall) do_uninstall ;;
+	*)
+		echo "usage: omp-config-xdev.sh install | uninstall" >&2
+		exit 2
+		;;
+esac

package/scripts/omp-tool-surface.py

@@ -56,14 +56,9 @@ def strip_comment(raw: str) -> str:
     return raw.rstrip()
 
 
-def parse_flow_seq(text: str) -> list[object] | None:
-    body = text.strip()
-    if not (body.startswith("[") and body.endswith("]")):
-        return None
-    inner = body[1:-1].strip()
-    if inner == "":
-        return []
-    items: list[object] = []
+def split_flow_items(inner: str) -> list[str] | None:
+    """Split a flow collection's body on its TOP-LEVEL commas (quote/nest aware)."""
+    items: list[str] = []
     buf: list[str] = []
     in_single = False
     in_double = False
@@ -83,16 +78,59 @@ def parse_flow_seq(text: str) -> list[object] | None:
             elif char in "]}":
                 depth -= 1
             elif char == "," and depth == 0:
-                items.append(parse_scalar("".join(buf).strip()))
+                items.append("".join(buf).strip())
                 buf = []
                 continue
         buf.append(char)
     if in_single or in_double or depth != 0:
         return None
-    items.append(parse_scalar("".join(buf).strip()))
+    items.append("".join(buf).strip())
     return items
 
 
+def parse_flow_seq(text: str) -> list[object] | None:
+    body = text.strip()
+    if not (body.startswith("[") and body.endswith("]")):
+        return None
+    inner = body[1:-1].strip()
+    if inner == "":
+        return []
+    parts = split_flow_items(inner)
+    if parts is None:
+        return None
+    return [parse_scalar(part) for part in parts]
+
+
+def parse_flow_map(text: str) -> dict[str, object] | None:
+    """The flow-mapping form the VENDOR itself writes.
+
+    omp's own settings writer emits `modelRoles:` followed by an indented `{}`
+    (measured on omp 18.0.0, an untouched operator config). The block-only reader
+    read that line as a malformed mapping and returned None for the WHOLE file, so
+    a perfectly ordinary vendor config classified as `unreadable` and the MCP
+    doctor went RED for a reason that had nothing to do with tools.xdev.
+    """
+    body = text.strip()
+    if not (body.startswith("{") and body.endswith("}")):
+        return None
+    inner = body[1:-1].strip()
+    if inner == "":
+        return {}
+    parts = split_flow_items(inner)
+    if parts is None:
+        return None
+    mapping: dict[str, object] = {}
+    for part in parts:
+        if part == "":
+            return None
+        pair = split_key_value(part)
+        if pair is None:
+            return None
+        key, raw = pair
+        mapping[key] = parse_scalar(raw)
+    return mapping
+
+
 def parse_scalar(raw: str) -> object:
     text = raw.strip()
     if text == "" or text in ("~", "null", "Null", "NULL"):
@@ -102,6 +140,9 @@ def parse_scalar(raw: str) -> object:
     if text.startswith("[") and text.endswith("]"):
         parsed = parse_flow_seq(text)
         return parsed if parsed is not None else text
+    if text.startswith("{") and text.endswith("}"):
+        parsed_map = parse_flow_map(text)
+        return parsed_map if parsed_map is not None else text
     folded = text.casefold()
     if folded in TRUE_WORDS:
         return True
@@ -137,6 +178,16 @@ def parse_block(lines: list[tuple[int, str]], start: int, indent: int) -> tuple[
     first_indent, first_text = lines[start]
     if first_indent <= indent:
         return {}, start
+    if first_text.startswith("{") or first_text.startswith("["):
+        # `key:` on one line, a flow collection indented under it on the next — the
+        # shape the vendor's own writer produces for an empty map (`modelRoles:\n  {}`).
+        flow = parse_flow_map(first_text) if first_text.startswith("{") else parse_flow_seq(first_text)
+        if flow is None:
+            return None, start
+        index = start + 1
+        if index < len(lines) and lines[index][0] >= first_indent:
+            return None, start  # a flow collection is the WHOLE block or nothing
+        return flow, index
     if first_text.startswith("- "):
         items: list[object] = []
         index = start