mishkan-harness 0.2.6 → 0.2.7

package/payload/mishkan/cognee/docker-compose.work.yml

@@ -0,0 +1,191 @@
+# MISHKAN — per-project cognee work store (decision D-012).
+#
+# Each project gets its OWN physically-separate cognee-mcp instance with an
+# embedded Ladybug graph + LanceDB vector + SQLite relational store. Isolation
+# is by topology (separate container + separate named volume + separate on-disk
+# graph file), NOT by cognee's datasets= filter (D-012 §Why: filter is advisory-
+# only with ENABLE_BACKEND_ACCESS_CONTROL=false; see issue #1023).
+#
+# Reuses the already-patched mishkan/cognee-mcp image — DO NOT rebuild from a
+# host source checkout. The recall fix (cognee-mcp-recall-user.py + core-align)
+# is baked into that image. Ref: decision D-012, amendment 2026-06-10.
+#
+# REQUIRED env vars (caller must export or set in the shell):
+#   COGNEE_MCP_REF   — pinned image tag (same ref used to build the base image)
+#   WORK_PROJECT     — project slug (e.g. "wisemoney", "harness"); becomes part of
+#                      container_name, volume name, and compose project name
+#   WORK_PORT        — host port the MCP endpoint binds on (127.0.0.1 only)
+#
+# Bring-up (always with the hardening overlay):
+#   export WORK_PROJECT=<slug> WORK_PORT=<port> COGNEE_MCP_REF=<ref>
+#   docker compose \
+#     -f docker-compose.work.yml \
+#     -f docker-compose.hardening.yml \
+#     -p mishkan-work-${WORK_PROJECT} \
+#     up -d
+#
+# The ensure-work-store.sh script wraps this with port assignment, health-wait,
+# and idempotency — prefer that over calling compose directly.
+#
+# Ollama (embeddings): the cognee-mcp container joins the EXTERNAL network
+# mishkan-cognee_cognee_net (created by docker-compose.selfhosted.yml) so it can
+# reach mishkan-ollama for embedding inference. The shared Ollama is model data,
+# not project data — sharing it does not breach the isolation boundary. If Ollama
+# is not running, cognee will fall back to whatever LLM_PROVIDER / LLM_API_KEY
+# is set in .env (a cloud provider), or fail at cognify time with a clear error.
+#
+# GRAPH_DATABASE_URL: if .env carries a stale NEO4J bolt URI for the old shared
+# work store, it is harmless here: when GRAPH_DATABASE_PROVIDER=ladybug the
+# cognee graph engine factory selects the LadybugAdapter directly and never
+# reads GRAPH_DATABASE_URL. No explicit unset is required; the environment
+# override below ensures the correct provider is always used.
+#
+# Volume layout — the per-project named volume mounts at the Dockerfile-owned,
+# cognee-owned /app/cognee-mcp/.cognee_system (writable by uid 10001). cognee
+# auto-places the embedded stores under the data/system roots (graph_file_path
+# has no env binding in v1.1.0 — it derives from SYSTEM_ROOT_DIRECTORY):
+#   .../system/databases/   — Ladybug graph (auto-named cognee_graph_kuzu)
+#   .../data , .../system   — LanceDB tables + SQLite relational + system metadata
+# This whole tree is the physical isolation boundary — never shared across projects.
+#
+# Migdal compliance: pinned image (no :latest), 127.0.0.1-bound, resource limits,
+# healthcheck, hardening overlay re-applied on every recreate (see Dockerfile
+# comment in docker-compose.hardening.yml).
+
+name: mishkan-work-${WORK_PROJECT:?set WORK_PROJECT to a project slug}
+
+services:
+  cognee-mcp:
+    image: mishkan/cognee-mcp:${COGNEE_MCP_REF:?set COGNEE_MCP_REF in .env to a pinned cognee git tag/commit}
+    container_name: mishkan-work-${WORK_PROJECT:?set WORK_PROJECT to a project slug}
+    restart: unless-stopped
+
+    # .env supplies LLM/embedding credentials (SOPS-managed by the engineer).
+    # The environment: block below OVERRIDES any stale graph/vector/relational
+    # provider vars that may be present in .env from the old shared Neo4j stack.
+    env_file:
+      - .env
+
+    environment:
+      COGNEE_PORT: "7777"
+
+      # Embedded backends — no server processes. We pin the PROVIDERS explicitly
+      # (a future .env change cannot silently redirect to a shared Neo4j), but we
+      # do NOT set graph/vector/relational FILE paths: in cognee v1.1.0
+      # `graph_file_path` has no env binding (verified, graph/config.py) — it is
+      # auto-derived under SYSTEM_ROOT_DIRECTORY. cognee places every embedded
+      # store under the data/system roots below, so the roots are what bind the
+      # stores to the per-project volume.
+      GRAPH_DATABASE_PROVIDER: "ladybug"   # cognee v1.1.0 default; embedded, file-based
+      VECTOR_DB_PROVIDER: "lancedb"        # embedded, file-based
+      DB_PROVIDER: "sqlite"                # embedded, file-based
+
+      # Data/system roots MUST live under /app/cognee-mcp/.cognee_system — the path
+      # the Dockerfile pre-creates and chowns to the non-root cognee user (uid
+      # 10001). A fresh volume at an un-pre-created path (e.g. /app/data) is
+      # root-owned and cognee cannot write to it (the persistence/ownership
+      # constraint documented in .env.example).
+      DATA_ROOT_DIRECTORY: "/app/cognee-mcp/.cognee_system/data"
+      SYSTEM_ROOT_DIRECTORY: "/app/cognee-mcp/.cognee_system/system"
+
+      # Access control off (cognee's multi-user mode needs a per-dataset DB which
+      # these embedded backends don't provide — see D-012). Isolation is by
+      # topology: this container + its own volume, not the datasets= filter.
+      ENABLE_BACKEND_ACCESS_CONTROL: "false"
+
+      # Session memory OFF on per-project stores so the conversational session
+      # cache accumulates ONLY in the shared `cognee-memory` instance (:7777),
+      # not fragmented per project. Verified (cognee v1.1.0): CACHING controls
+      # the single `caching` field (cache/config.py:26) and disables ONLY the
+      # session/conversational cache (+ auto_feedback, off by default) — it does
+      # NOT disable embedding/LLM/query caching, and recall/cognify/search keep
+      # working (get_cache_engine.py:46; retrievers' no-session completion path).
+      # NB: the permanent `claude_code_memory` graph dataset is governed by
+      # COGNEE_MCP_AGENT_SCOPED, NOT CACHING — it is unaffected here.
+      CACHING: "false"
+
+      # Agent-scoping OFF so a per-project store NEVER creates a per-client
+      # `claude_code_memory` graph dataset (which would fragment session learnings
+      # across projects). Verified (cognee v1.1.0, cognee-mcp server.py:1686/1711):
+      # default "true" auto-names the default dataset `<client>_memory`; "false"
+      # collapses it to `main_dataset`, so this store holds ONLY project knowledge.
+      # `claude_code_memory` lives solely in the shared `cognee-memory` instance
+      # (which keeps the default). mishkan-ingest writes explicit dataset names so
+      # it is unaffected; datasets= is advisory (one store = one project) so
+      # whole-graph recall still returns this project's data. Topology, not trust.
+      COGNEE_MCP_AGENT_SCOPED: "false"
+
+      # Ontology (ADR D-013): attach the MISHKAN schema to every cognify so ingested
+      # entities matching a class are validated (ontology_valid=true) and enriched
+      # with parent / object-property edges. cognee v1.1.0 reads the ontology from
+      # the ENVIRONMENT (Pydantic OntologyEnvConfig) — NOT a cognify kwarg, which it
+      # silently ignores. The resolver/strategy already default to these values; we
+      # set all three explicitly. ONTOLOGY_FILE_PATH points at the ttl that
+      # ensure-work-store.sh stages into the container; fail-open — if the file is
+      # missing cognee logs a warning and ingests ontology-free.
+      ONTOLOGY_RESOLVER: "rdflib"
+      MATCHING_STRATEGY: "fuzzy"
+      ONTOLOGY_FILE_PATH: "/home/cognee/ontology.ttl"
+
+    ports:
+      # Bound to loopback only. WORK_PORT is assigned by ensure-work-store.sh
+      # (deterministic: base 7800 + hash of slug, no conflict with 7777/7730).
+      - "127.0.0.1:${WORK_PORT:?set WORK_PORT to the desired host port}:7777"
+
+    volumes:
+      # Per-project named volume mounted at the Dockerfile-owned .cognee_system
+      # path (writable by the non-root cognee user). The compose project name
+      # (mishkan-work-<slug>) is prepended by Docker → mishkan-work-<slug>_work_data.
+      # This volume is the physical isolation boundary: each project's graph,
+      # vector, and relational files live here and are never visible to others.
+      - work_data:/app/cognee-mcp/.cognee_system
+
+    networks:
+      # Join the shared network so this container can reach mishkan-ollama for
+      # embedding inference. This network is created by docker-compose.selfhosted.yml
+      # (name: mishkan-cognee, network alias cognee_net → external name
+      # mishkan-cognee_cognee_net). If the selfhosted stack is not running, bring
+      # it up first or point the embedding config at a cloud provider via .env.
+      - cognee_shared_net
+
+    healthcheck:
+      # Conditional probe WITH internal retries: connect up to 3 times (1s apart, no
+      # trailing sleep), exit 0 on the first success — absorbs a transient blip
+      # without flagging a failure. CMD-SHELL wraps the python connect in the retry
+      # loop; `$$i` is escaped so compose passes a literal $i through to the shell.
+      test: ["CMD-SHELL", "for i in 1 2 3; do python -c \"import socket; socket.create_connection(('127.0.0.1',7777),2).close()\" 2>/dev/null && exit 0; [ \"$$i\" = 3 ] || sleep 1; done; exit 1"]
+      interval: 15s
+      timeout: 10s
+      retries: 5
+      # 300s: cognee-mcp cold-start is slow (~4-5min — cognee lib import + graph
+      # init + ollama embedding warmup + DB migrations before it binds :7777). A
+      # 40s grace flags a still-booting container unhealthy on every cold start.
+      # A generous start_period only delays the first probe; it never slows a
+      # healthy container. Matches the shared :7777 box (base compose) at 300s.
+      start_period: 300s
+      # start_interval (Docker 25+): probe every 5s during start_period so the health
+      # flip is caught within ~5s of :7777 binding, not up to 15s later.
+      start_interval: 5s
+
+    deploy:
+      resources:
+        limits:
+          # Lighter than the Neo4j-backed store (no JVM): 1.5 CPU / 2 GB.
+          # Ladybug + LanceDB + SQLite are all in-process — no separate server
+          # processes sharing the cgroup. Raise if bulk cognify is slow.
+          cpus: "1.5"
+          memory: 2g
+
+volumes:
+  work_data:
+    # Unnamed here; Docker prefixes the compose project name automatically:
+    #   mishkan-work-<WORK_PROJECT>_work_data
+    # Each project therefore owns a distinct, unambiguously-named volume.
+
+networks:
+  cognee_shared_net:
+    # External: created by the selfhosted stack (mishkan-cognee project,
+    # network cognee_net). Join it to reach mishkan-ollama for embeddings.
+    # Do NOT re-declare subnet here — Docker will reject a conflicting config.
+    external: true
+    name: mishkan-cognee_cognee_net

package/payload/mishkan/cognee/docker-compose.yml

@@ -39,11 +39,26 @@ services:
       # Cognee's local data (graph/vector/sqlite) when using default backends.
       - cognee_data:/app/cognee-mcp/.cognee_system
     healthcheck:
-      test: ["CMD", "python", "-c", "import socket; s=socket.create_connection(('127.0.0.1',7777),2); s.close()"]
+      # Conditional probe WITH internal retries: connect up to 3 times (1s apart, no
+      # trailing sleep), exit 0 on the first success — absorbs a transient blip
+      # without flagging a failure. CMD-SHELL wraps the python connect in the retry
+      # loop; `$$i` is escaped so compose passes a literal $i through to the shell.
+      test: ["CMD-SHELL", "for i in 1 2 3; do python -c \"import socket; socket.create_connection(('127.0.0.1',7777),2).close()\" 2>/dev/null && exit 0; [ \"$$i\" = 3 ] || sleep 1; done; exit 1"]
       interval: 15s
-      timeout: 5s
+      timeout: 10s
       retries: 5
-      start_period: 40s
+      # 300s: cognee-mcp cold-start is genuinely slow — observed ~3.5min just to
+      # reach DB migrations (cognee lib import + graph-adapter handshake + ollama
+      # embedding warmup) and ~4-5min before it binds :7777. A 40s grace flagged a
+      # perfectly-fine, still-booting container unhealthy on EVERY cold start, then
+      # cascaded to anything with depends_on: service_healthy. It self-recovers the
+      # moment the port listens, but the false-unhealthy window is the bug. start_period
+      # must cover the real cold-start; a too-long value only delays the first probe,
+      # it never slows a healthy container. Sibling Neo4j is 240s for the same reason.
+      start_period: 300s
+      # start_interval (Docker 25+): probe every 5s during start_period so the health
+      # flip is caught within ~5s of :7777 binding, not up to 15s later.
+      start_interval: 5s
     networks:
       - cognee_net
     deploy:

package/payload/mishkan/cognee/patches/cognee-mcp-core-align.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""MISHKAN overlay patch — align cognee CORE to the pinned cognee-mcp ref.
+
+The Dockerfile clones the cognee monorepo at COGNEE_MCP_REF (e.g. v1.1.0) and
+runs `uv sync` inside `cognee-mcp/`. But cognee-mcp's pyproject pins the core
+LOOSELY against PyPI:
+
+    "cognee[postgres-binary,docs,neo4j]>=1.0.0,<2.0.0"
+
+so `uv sync` installs the core from PyPI at whatever the latest 1.x happens to
+be — a DIFFERENT version than the checked-out wrapper. That skew is what breaks
+the read path even after the recall/search `user=` patch (cognee-mcp-recall-
+user.py): the v1.1.0 core's recall() forwards `user=` exactly once, but the
+drifting PyPI core's recall() passes it both positionally and as a keyword, so
+the wrapper's injected `user=` collides:
+
+    authorized_search() got multiple values for keyword argument 'user'
+
+The fix: resolve the core from the LOCAL checkout (`/app`, the monorepo root,
+which is a PEP-517 `cognee` package built by hatchling) via a PEP 508 direct
+reference. Then wrapper + core + their transitive deps are all the same ref, and
+the recall patch — written against that ref — works end to end. This is exactly
+the mechanism the upstream dev left commented out (a `@ file:` direct ref),
+generalised off their hard-coded local path to the in-container clone.
+
+Properties (mirrors cognee-mcp-recall-user.py):
+  - idempotent: re-running is a no-op (marker = the rewritten dep string).
+  - fail-loud: if the loose-pin anchor is not found (a COGNEE_MCP_REF bump moved
+    or already fixed it), exits non-zero so the build fails instead of silently
+    shipping a still-skewed image.
+
+Drop this patch (and its Dockerfile COPY/RUN) once cognee-mcp pins its core
+tightly to the wrapper ref upstream and COGNEE_MCP_REF is bumped to it.
+"""
+from __future__ import annotations
+
+import pathlib
+import sys
+
+TARGET = pathlib.Path("/app/cognee-mcp/pyproject.toml")
+OLD = '"cognee[postgres-binary,docs,neo4j]>=1.0.0,<2.0.0"'
+NEW = '"cognee[postgres-binary,docs,neo4j] @ file:///app"'
+
+
+def main() -> int:
+    if not TARGET.is_file():
+        print(f"MISHKAN ERROR: {TARGET} not found", file=sys.stderr)
+        return 1
+
+    src = TARGET.read_text()
+    if NEW in src:
+        print("MISHKAN: cognee core already aligned to /app checkout; skipping")
+        return 0
+
+    count = src.count(OLD)
+    if count != 1:
+        print(
+            f"MISHKAN ERROR: expected exactly 1 core-dep anchor, found {count}. "
+            "cognee-mcp/pyproject.toml changed its core pin — review "
+            "payload/mishkan/cognee/patches/cognee-mcp-core-align.py against the "
+            "pinned COGNEE_MCP_REF.",
+            file=sys.stderr,
+        )
+        return 1
+
+    TARGET.write_text(src.replace(OLD, NEW))
+    print("MISHKAN: cognee core pinned to /app checkout (file:///app)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/payload/mishkan/cognee/patches/cognee-mcp-recall-user.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""MISHKAN overlay patch for cognee-mcp (v1.1.0 .. v1.1.2).
+
+Upstream defect (cognee issue #2855): CogneeClient.recall() and .search() in
+direct/local mode call cognee.recall()/cognee.search() WITHOUT a `user=`
+argument, so the core resolves the user itself and — under several conditions
+(notably a Neo4j graph backend, where the non-ACL search branch runs) — the
+read path dereferences `.id` on a None and raises:
+
+    'NoneType' object has no attribute 'id'
+
+The WRITE path works because add()/cognify()/remember() initialise the user and
+datasets; only the READ path is broken. The sibling methods delete() and
+list_datasets() already do `user = await get_default_user()` and pass it — this
+patch makes recall()/search() do the same, mirroring that exact pattern.
+
+Properties:
+  - idempotent: re-running is a no-op (marker `_mishkan_gdu`).
+  - fail-loud: if the two anchor call-sites are not found (e.g. a cognee-mcp
+    upgrade moved or fixed them), exits non-zero so the build fails loudly
+    instead of silently shipping an unpatched (still-broken) image.
+  - indentation-safe: the injected lines copy the anchor line's own indent.
+
+Drop this patch (and its Dockerfile COPY/RUN) once a cognee-mcp release lands
+the fix upstream and COGNEE_MCP_REF is bumped to it.
+"""
+from __future__ import annotations
+
+import pathlib
+import sys
+
+TARGET = pathlib.Path("/app/cognee-mcp/src/cognee_client.py")
+MARKER = "_mishkan_gdu"
+IMPORT = "from cognee.modules.users.methods import get_default_user as _mishkan_gdu"
+
+# (anchor line — matched after lstrip; kwargs-dict the call splats)
+EDITS = [
+    ("return await self.cognee.recall(query_text=query_text, **kwargs)", "kwargs"),
+    ("results = await self.cognee.search(**search_kwargs)", "search_kwargs"),
+]
+
+
+def main() -> int:
+    if not TARGET.is_file():
+        print(f"MISHKAN ERROR: {TARGET} not found", file=sys.stderr)
+        return 1
+
+    src = TARGET.read_text()
+    if MARKER in src:
+        print("MISHKAN: cognee-mcp recall/search user= patch already applied; skipping")
+        return 0
+
+    out: list[str] = []
+    applied = 0
+    for line in src.splitlines(keepends=True):
+        stripped = line.lstrip()
+        indent = line[: len(line) - len(stripped)]
+        hit = next((kw for anchor, kw in EDITS if stripped.startswith(anchor)), None)
+        if hit is not None:
+            out.append(f"{indent}{IMPORT}\n")
+            out.append(f'{indent}{hit}["user"] = await _mishkan_gdu()\n')
+            out.append(line)
+            applied += 1
+        else:
+            out.append(line)
+
+    if applied != len(EDITS):
+        print(
+            f"MISHKAN ERROR: expected {len(EDITS)} patch site(s), found {applied}. "
+            "cognee-mcp source changed — review payload/mishkan/cognee/patches/"
+            "cognee-mcp-recall-user.py against the pinned COGNEE_MCP_REF.",
+            file=sys.stderr,
+        )
+        return 1
+
+    TARGET.write_text("".join(out))
+    print(f"MISHKAN: cognee-mcp recall/search user= patch applied ({applied} sites)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/payload/mishkan/cognee/promote-curated.py

@@ -0,0 +1,77 @@
+# MISHKAN — ADDITIVE promotion of a single resource into the curated library (D-016).
+# Runs INSIDE the cognee-curated-mcp container (needs the cognee package + the live
+# .env config: graph=Neo4j, vector=pgvector, embeddings=Ollama). Writes ONE typed
+# CuratedResource node via Cognee's low-level DataPoint API — NO LLM extraction
+# (cognify), so it costs only embedding calls.
+#
+# This is the engineer-gated growth path for the curated library: a resource a
+# research run found reusable, vetted by Shemaiah, queued by Baruch, and approved
+# by the engineer via `mishkan knowledge curate`. Invoked by promote-curated.sh;
+# not meant to be run standalone on the host.
+#
+#   Candidate JSON path via COGNEE_CANDIDATE_JSON (default /home/cognee/curated-candidate.json)
+#
+# CRITICAL — unlike ingest-curated.py (the seed), this NEVER prunes. The seed wipes
+# and rewrites for a clean reproducible bootstrap; promotion is additive, so every
+# pre-existing curated node MUST survive. Dedup by url is enforced by the caller
+# (promote-curated.sh) against the seed manifest + the promoted ledger before this
+# script is ever invoked — so reaching here means "write this new node".
+import asyncio
+import json
+import os
+
+from cognee.low_level import setup, DataPoint
+from cognee.pipelines import run_tasks, Task
+from cognee.tasks.storage import add_data_points
+from cognee.tasks.storage.index_graph_edges import index_graph_edges
+from cognee.modules.users.methods import get_default_user
+from cognee.modules.data.methods import load_or_create_datasets
+
+CANDIDATE = os.environ.get("COGNEE_CANDIDATE_JSON", "/home/cognee/curated-candidate.json")
+
+
+class CuratedResource(DataPoint):
+    name: str
+    team: str
+    url: str
+    problem_class: str
+    source_tier: str
+    metadata: dict = {"index_fields": ["name", "problem_class"]}
+
+
+def build_node(_data=None):
+    with open(CANDIDATE) as fh:
+        d = json.load(fh)
+    for required in ("name", "team", "url"):
+        if not d.get(required):
+            raise SystemExit(f"promote-curated: candidate missing required field '{required}'")
+    node = CuratedResource(
+        name=d["name"],
+        team=d["team"],
+        url=d["url"],
+        problem_class=d.get("problem_class", ""),
+        source_tier=d.get("source_tier", "curated"),
+    )
+    print(f">> built 1 CuratedResource node: {node.name} ({node.url})", flush=True)
+    return [node]
+
+
+async def main():
+    # NO prune — additive. Pre-existing curated nodes must survive.
+    await setup()
+    user = await get_default_user()
+    datasets = await load_or_create_datasets(["curated_library"], [], user)
+    tasks = [Task(build_node), Task(add_data_points)]
+    async for status in run_tasks(tasks, datasets[0].id, None, user, "curated_promote"):
+        print(">> status:", getattr(status, "status", status), flush=True)
+    await index_graph_edges()
+    print(">> PROMOTED", flush=True)
+    # Enrichment follows the build: memify embeds the relationship/triplet layer
+    # (default tasks; embeddings-only, no LLM/quota).
+    import cognee
+    await cognee.memify(dataset="curated_library")
+    print(">> MEMIFIED", flush=True)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/payload/mishkan/cognee/prune-store.py

@@ -0,0 +1,23 @@
+# MISHKAN — prune a cognee store to empty. Runs INSIDE a cognee-mcp container
+# (needs the cognee package + the live .env config). Wipes ALL data AND system
+# metadata in that container's graph + vector + relational stores.
+#
+# Used by reset-knowledge-data.sh to clear cognee-memory (:7777) during a full
+# knowledge-data reset to the stable baseline. Mirrors the prune the seed does
+# (ingest-curated.py) but standalone — prune only, no re-write.
+#
+# DESTRUCTIVE and IRREVERSIBLE. Not meant to be run standalone on the host;
+# the orchestrator docker-execs it under the engineer's hand.
+import asyncio
+
+from cognee import prune
+
+
+async def main():
+    await prune.prune_data()
+    await prune.prune_system(metadata=True)
+    print(">> PRUNED (data + system metadata)", flush=True)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/payload/mishkan/commands/mishkan-init.md

@@ -18,7 +18,10 @@ Nehemiah → `docs/PRD.md`
 → Benaiah → `docs/THREAT_MODEL.md` (plan first)
 → Meshullam → `docs/diagrams/C4/` (plan first)
 → Jehoshaphat → `docs/README.md`, `docs/adr/`, `docs/runbooks/` (plan first)
-→ seed Cognee from all docs
+→ knowledge setup (D-007 + D-012 + D-015): `mishkan knowledge-stack up` (shared
+  infra, idempotent) + `mishkan project-work-store up` (this project's isolated
+  store) + `mishkan knowledge ingest --tagged-only` (ONLY `mishkan: ingest`-tagged
+  docs — never bulk-ingest the tree; selective by design, prevents PII bleed)
 → write `./CLAUDE.md` (Sprint S0), copy settings + team rules into `.claude/`
 
 Sequence before implementation: no code is written during init. Stateful

package/payload/mishkan/commands/mishkan-org-reference.md

@@ -25,13 +25,13 @@ The data source is `~/.claude/mishkan/org/org.json`, generated from
 Invoke the harness CLI:
 
 ```bash
-npx mishkan-harness org
+npx mishkan-harness org show
 ```
 
 For a structured JSON dump (e.g. to feed another tool):
 
 ```bash
-npx mishkan-harness org --json
+npx mishkan-harness org show --json
 ```
 
 Always present the printed reference back to the user verbatim — do not

package/payload/mishkan/config/curated-library.yaml

@@ -104,6 +104,7 @@ sefer:   # Documentation
   - { name: "Google Dev Documentation Style Guide", url: "https://developers.google.com/style", problem_class: "technical-writing-style" }
   - { name: "MADR ADR template", url: "https://adr.github.io/madr/", problem_class: "adr-format" }
   - { name: "C4 Model", url: "https://c4model.com/", problem_class: "architecture-diagrams" }
+  - { name: "Mermaid — validate diagrams without a browser (mermaid.parse() under jsdom, no Chromium)", url: "https://mermaid.js.org/intro/syntax-reference.html", problem_class: "diagram-as-code-validation" }
   - { name: "Keep a Changelog", url: "https://keepachangelog.com/en/1.1.0/", problem_class: "changelog-convention" }
   - { name: "Semantic Versioning 2.0", url: "https://semver.org/", problem_class: "versioning" }
   - { name: "Conventional Commits", url: "https://www.conventionalcommits.org/en/v1.0.0/", problem_class: "commit-convention" }

package/payload/mishkan/config/model-routing.yaml

@@ -3,11 +3,18 @@
 # every Task/Agent call and injects `model` for any agent LISTED below, which
 # overrides that agent's frontmatter `model:`. So this file is the single source
 # of truth for the 45 MISHKAN agents. Agents NOT listed here (e.g. aiobi-ops,
-# Explore) are left untouched and keep their own frontmatter model. Three tiers:
-# opus, sonnet, haiku. (Edit here, not frontmatter — frontmatter is the fallback
-# used only if the hook is removed.)
+# Explore) are left untouched and keep their own frontmatter model. The hook
+# accepts four tier values — fable, opus, sonnet, haiku — but `fable` is currently
+# DORMANT (no agent routed to it; see below). (Edit here, not frontmatter —
+# frontmatter is the fallback used only if the hook is removed.)
 #
 # Rationale per tier:
+#   fable  — SUSPENDED 2026-06-12. Claude Fable 5 (claude-fable-5) was disabled for
+#            all customers by a US export-control directive (anthropic.com/news/
+#            fable-mythos-access); it now hard-errors on spawn. The Migdal+Mishmar
+#            specialists that briefly ran on it (D-002 2026-06-11 amend) are reverted
+#            to sonnet below. The tier value is KEPT VALID so re-enabling is a one-line
+#            change if Anthropic restores access — but route NO agent here until then.
 #   opus   — orchestration, team leadership, knowledge publication (judgement-heavy)
 #   sonnet — anything that WRITES code/config into the codebase (precision matters
 #            on Y4NN's code) + senior specialists + research clarify/formulate/research
@@ -35,10 +42,10 @@ agents:
 
   # Mishmar (Security)
   phinehas: opus      # lead
-  ira: sonnet
-  benaiah: sonnet
-  joab: sonnet
-  hushai: sonnet
+  ira: sonnet         # was fable (D-002 amend); reverted 2026-06-12 — Fable suspended
+  benaiah: sonnet     # was fable; reverted 2026-06-12 — Fable suspended
+  joab: sonnet        # was fable; reverted 2026-06-12 — Fable suspended
+  hushai: sonnet      # was fable; reverted 2026-06-12 — Fable suspended
   maaseiah: haiku     # reporter
 
   # Yasad (Backend)
@@ -67,10 +74,10 @@ agents:
 
   # Migdal (Infrastructure)
   eliashib: opus      # lead
-  meshullam: sonnet   # infra design
-  palal: sonnet       # writes system configs/scripts
-  meremoth: sonnet    # writes CI/pipeline code
-  hanun: sonnet       # writes hardening/observability config
+  meshullam: sonnet   # was fable (D-002 amend); reverted 2026-06-12 — Fable suspended
+  palal: sonnet       # was fable; reverted 2026-06-12 — Fable suspended
+  meremoth: sonnet    # was fable; reverted 2026-06-12 — Fable suspended
+  hanun: sonnet       # was fable; reverted 2026-06-12 — Fable suspended
   rehum: haiku        # advisor — no code
   zaccur: haiku       # reporter
 
@@ -82,6 +89,8 @@ agents:
   jehonathan: opus    # knowledge publication
   huldah: haiku       # reporter
 
-# Tier totals: opus=9, sonnet=22, haiku=14  (45 agents)
-# Principle: any agent that writes code/config into the codebase runs on Sonnet
-# (precision on Y4NN's code). Haiku only for evaluate/collect/advise roles.
+# Tier totals: fable=0 (SUSPENDED 2026-06-12), opus=9, sonnet=22, haiku=14  (45 agents)
+# Principle: every agent that writes code/config runs on Sonnet (precision on Y4NN's
+# code); opus for orchestration/leadership/publication; Haiku only for
+# evaluate/collect/advise roles. The fable tier is retained as a valid value but
+# dormant (Fable 5 disabled by export-control directive). See D-002 (amended twice).

package/payload/mishkan/evals/baruch/fixtures/invalid/bad-curated-candidate.json

@@ -0,0 +1,22 @@
+{
+  "agent": "benaiah",
+  "team": "mishmar",
+  "sprint": "S3",
+  "trigger": "faced_problem",
+  "query_intent": "Authoritative guidance for verifying container provenance with cosign.",
+  "tools_invoked": ["jakin", "ezra", "caleb", "shaphan", "shemaiah", "baruch"],
+  "research_output_summary": "Cosign verify-attestation covers the verify step. Confidence: high.",
+  "applied_to_task": "T-9",
+  "outcome": "resolved",
+  "knowledge_graph_write": true,
+  "curated_library_match": false,
+  "cognee_node_id": "casenode-7f3a92",
+  "curated_promotion_candidate": {
+    "name": "Sigstore cosign",
+    "url": "",
+    "problem_class": "supply-chain-provenance",
+    "team": "mishmar",
+    "source_tier": "primary",
+    "why": "Reusable across projects that build containers."
+  }
+}

package/payload/mishkan/evals/baruch/fixtures/valid/resolved-curated-candidate.json

@@ -0,0 +1,23 @@
+{
+  "agent": "benaiah",
+  "team": "mishmar",
+  "sprint": "S3",
+  "trigger": "faced_problem",
+  "query_intent": "Authoritative guidance for pinning container base images by digest and verifying provenance with cosign in a GitLab CI pipeline.",
+  "tools_invoked": ["jakin", "ezra", "caleb", "shaphan", "shemaiah", "baruch"],
+  "research_output_summary": "Sigstore cosign verify-attestation + the SLSA provenance v1 predicate cover the verify step; pinning by digest (not tag) closes the mutable-tag gap. Primary sources: sigstore docs + SLSA spec. Confidence: high. Reusable across any project that builds containers.",
+  "applied_to_task": "T-9",
+  "outcome": "resolved",
+  "knowledge_graph_write": true,
+  "curated_library_match": false,
+  "cognee_node_id": "casenode-7f3a91",
+  "timestamp": "2026-06-11T10:04:00Z",
+  "curated_promotion_candidate": {
+    "name": "Sigstore cosign — verify-attestation + SLSA provenance",
+    "url": "https://docs.sigstore.dev/cosign/verifying/verify/",
+    "problem_class": "supply-chain-provenance",
+    "team": "mishmar",
+    "source_tier": "primary",
+    "why": "Vendor-neutral, applies to every project that builds and signs containers — not specific to this codebase."
+  }
+}