From 8cdfb21116892885a0bfa014ff0d7171f2761407 Mon Sep 17 00:00:00 2001
From: DTALEX66 <DTALEX66@users.noreply.github.com>
Date: Sun, 9 Aug 2026 22:22:06 +0800
Subject: [PATCH 1/8] fix(ci): gate ci-verdict on semantic GatePlan IDs
 (AXW-003A)

GatePlan emits semantic gate IDs (py-primary, static, lint, ...), not
GitHub job names. The aggregator previously ran 'require test' against the
job name, which GatePlan never emits, letting a required py-primary suite
failure pass ci-verdict as green. Gate on the semantic IDs now: py-primary
carries the OS/KB/integration test result, static and lint both arrive via
the lint job. Not-required-but-failed coverage now includes test, py-compat
and lint, and the windows-runtime-smoke job name is corrected.
---
 .github/workflows/ci.yml  | 19 +++++++++++----
 tests/test_ci_a0_gates.py | 49 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ff99b78..54c7289 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -673,20 +673,29 @@ jobs:
               fi
             fi
           }
-          require test "$TEST_RESULT"
-          require py-compat "$COMPAT_RESULT"
+          # AXW-003A: gate on the GatePlan semantic IDs, not GitHub job names.
+          # GatePlan emits `py-primary` for the OS/KB/integration suite (its
+          # result arrives via the `test` job) and `static` for convention and
+          # architecture checks (carried by the `lint` job). Requiring the bare
+          # job name `test` would never match GatePlan and would let a required
+          # py-primary failure pass as green.
+          require py-primary "$TEST_RESULT"
+          require static "$LINT_RESULT"
           require lint "$LINT_RESULT"
+          require py-compat "$COMPAT_RESULT"
           require wheel-smoke "$WHEEL_RESULT"
           require browser-smoke "$BROWSER_RESULT"
           require windows-runtime "$WINDOWS_RESULT"
           require desktop-fast "$DESKTOP_FAST_RESULT"
           require desktop-build "$DESKTOP_BUILD_RESULT"
           require installer-lifecycle "$INSTALLER_RESULT"
-          # A not-required job that RAN and failed is still a failure.
-          for spec in "wheel-smoke:$WHEEL_RESULT" "browser-smoke:$BROWSER_RESULT" "windows-runtime:$WINDOWS_RESULT" "desktop-fast:$DESKTOP_FAST_RESULT" "desktop-build:$DESKTOP_BUILD_RESULT" "installer-lifecycle:$INSTALLER_RESULT"; do
+          # A not-required job that RAN and failed is still a failure. Use the
+          # job names (the only labels the `needs.*.result` are keyed by) but
+          # check them against their real job results.
+          for spec in "test:$TEST_RESULT" "py-compat:$COMPAT_RESULT" "lint:$LINT_RESULT" "wheel-smoke:$WHEEL_RESULT" "browser-smoke:$BROWSER_RESULT" "windows-runtime-smoke:$WINDOWS_RESULT" "desktop-fast:$DESKTOP_FAST_RESULT" "desktop-build:$DESKTOP_BUILD_RESULT" "installer-lifecycle:$INSTALLER_RESULT"; do
             name="${spec%%:*}"; result="${spec##*:}"
             if [ "$result" = "failure" ]; then
-              echo "gate '$name' failed even though not required"
+              echo "job '$name' failed even though its gate was not required"
               exit 1
             fi
           done
diff --git a/tests/test_ci_a0_gates.py b/tests/test_ci_a0_gates.py
index e788b7e..17e1368 100644
--- a/tests/test_ci_a0_gates.py
+++ b/tests/test_ci_a0_gates.py
@@ -210,6 +210,55 @@ def test_ci_exposes_one_stable_a0_required_check() -> None:
     assert "ci-verdict: all required gates success" in workflow
 
 
+def test_ci_verdict_requires_semantic_gate_ids_not_job_names() -> None:
+    """AXW-003A: the aggregator must gate on GatePlan semantic IDs, not the
+    GitHub job name. GatePlan emits `py-primary` for the OS/KB suite and
+    `static` for convention/architecture checks. A `require test` that matches
+    the job name instead of the gate ID can never fire, letting a required
+    `py-primary` failure slip through as a green ci-verdict.
+    """
+    workflow = WORKFLOW.read_text(encoding="utf-8")
+    verdict = workflow.split("Validate required gates against GatePlan", 1)[1]
+
+    # The aggregator must reference every required-conditional gate by its
+    # semantic GatePlan ID (the same string the classifier emits), not a bare
+    # GitHub job name.
+    for gate_id in (
+        "py-primary",
+        "static",
+        "lint",
+        "py-compat",
+        "wheel-smoke",
+        "browser-smoke",
+        "windows-runtime",
+        "desktop-fast",
+        "desktop-build",
+        "installer-lifecycle",
+    ):
+        assert f"require {gate_id}" in verdict, f"ci-verdict missing require {gate_id}"
+
+    # The job name `test` is not a GatePlan ID; requiring it is a no-op that
+    # would mask a required py-primary failure. Its presence is the AXW-003A bug.
+    assert "require test " not in verdict.replace("test ", "", 0).replace(
+        "py-primary", ""
+    ) or "require test " not in verdict
+
+
+def test_ci_verdict_does_not_require_orphan_job_name_test() -> None:
+    """AXW-003A reverse regression: ci-verdict must never `require test` because
+    GatePlan never emits a `test` gate; `py-primary` is the semantic ID for the
+    OS/KB/integration suite. Requiring `test` (the GitHub job name) is dead code
+    that lets a required py-primary suite failure pass the aggregate.
+    """
+    workflow = WORKFLOW.read_text(encoding="utf-8")
+    verdict = workflow.split("Validate required gates against GatePlan", 1)[1]
+    # The verdict body must not contain a `require test` invocation (job-name gate).
+    # It may mention `test` in the env var TEST_RESULT only, not as a require key.
+    assert "require test " not in verdict
+    # Sanity: the suite env var that carries the OS/KB test result is present.
+    assert "TEST_RESULT" in verdict
+
+
 def test_selective_heavy_jobs_gate_on_gateplan() -> None:
     workflow = WORKFLOW.read_text(encoding="utf-8")
 

From 275bd904b5eb00fa02adee4d596cfa909a6c71fb Mon Sep 17 00:00:00 2001
From: DTALEX66 <DTALEX66@users.noreply.github.com>
Date: Sun, 9 Aug 2026 22:22:11 +0800
Subject: [PATCH 2/8] feat(scripts): add Windows/PowerShell 7 doctor (AXW-007A)

Detect Python, Node, Rust, PowerShell, Chinese and space-containing paths,
port availability, console encoding and writable project-local directories.
Emits sanitized structured JSON only (no absolute private paths, secrets or
personal body text). Covered by six focused tests.
---
 scripts/doctor_windows.ps1   | 146 +++++++++++++++++++++++++++++++++++
 tests/test_doctor_windows.py |  93 ++++++++++++++++++++++
 2 files changed, 239 insertions(+)
 create mode 100644 scripts/doctor_windows.ps1
 create mode 100644 tests/test_doctor_windows.py

diff --git a/scripts/doctor_windows.ps1 b/scripts/doctor_windows.ps1
new file mode 100644
index 0000000..eee771f
--- /dev/null
+++ b/scripts/doctor_windows.ps1
@@ -0,0 +1,146 @@
+#requires -Version 7.0
+<#
+    SYNOPSIS
+      Windows/PowerShell 7 doctor for Cognitive-Loop-OS (AXW-007A).
+
+    DESCRIPTION
+      Detects the toolchain and Windows-environment prerequisites needed to run,
+      test, and package the project: Python, Node, Rust, PowerShell, Chinese and
+      space-containing paths, port availability, console encoding, and writable
+      directories.
+
+      Output is strictly sanitized: it never prints secrets, tokens, cookies,
+      credentials, private paths outside the declared scope, or personal body
+      text. Only names, versions, availability booleans and path-layout facts are
+      emitted. All results are returned as structured JSON on stdout; warnings go
+      to stderr.
+
+    OUTPUT
+      A single JSON object:
+      {
+        "schema_version": "axw.007a.v1",
+        "generated_at": "...",
+        "toolchain": { "python": {...}, "node": {...}, "rust": {...}, "powershell": {...} },
+        "paths": { "space_in_path": bool, "non_ascii_in_path": bool, "project_root": "<sanitized>", ... },
+        "ports": { "<label>": { "port": int, "available": bool } },
+        "encoding": { "console_codepage": int, "utf8_default": bool },
+        "writable": [ { "label": "...", "path": "...", "writable": bool } ],
+        "healthy": bool
+      }
+
+    PARAMETER ProjectRoot
+      Optional absolute path to the repository root. Defaults to the script's
+      parent (project checkout). Used only to detect path-layout facts and
+      writable-directory checks; the emitted path is a relative or sanitized form.
+
+    EXAMPLE
+      pwsh -NoProfile -File scripts/doctor_windows.ps1
+#>
+[CmdletBinding()]
+param(
+    [string]$ProjectRoot = (Resolve-Path (Join-Path $PSScriptRoot ".."))
+)
+
+$ErrorActionPreference = "Continue"
+
+function Test-CommandAvailable {
+    param([string]$Name)
+    return [bool](Get-Command $Name -ErrorAction SilentlyContinue)
+}
+
+function Get-Version([string]$Name) {
+    $cmd = Get-Command $Name -ErrorAction SilentlyContinue
+    if (-not $cmd) { return $null }
+    try {
+        $v = & $Name --version 2>$null | Select-Object -First 1
+        return $v
+    } catch { return $null }
+}
+
+function Test-PortAvailable([int]$Port) {
+    try {
+        $listener = [System.Net.Sockets.TcpListener]::new([System.Net.IPAddress]::Loopback, $Port)
+        $listener.Start()
+        $listener.Stop()
+        return $true
+    } catch { return $false }
+}
+
+$result = [ordered]@{}
+
+# --- Toolchain -----------------------------------------------------------
+$result.schema_version = "axw.007a.v1"
+$result.generated_at = (Get-Date -Format o)
+
+$python = [ordered]@{ present = $false }
+if (Test-CommandAvailable "python") { $python.present = $true; $python.version = Get-Version "python" }
+if (Test-CommandAvailable "py")    { $python.launcher_present = $true }
+
+$node = [ordered]@{ present = $false }
+if (Test-CommandAvailable "node") { $node.present = $true; $node.version = Get-Version "node" }
+if (Test-CommandAvailable "npm")  { $node.npm_present = $true }
+
+$rust = [ordered]@{ present = $false }
+if (Test-CommandAvailable "cargo") { $rust.present = $true; $rust.version = Get-Version "cargo" }
+if (Test-CommandAvailable "rustc") { $rust.rustc_present = $true }
+
+$ps = [ordered]@{ present = $true; version = $PSVersionTable.PSVersion.ToString() }
+
+$result.toolchain = [ordered]@{
+    python      = $python
+    node        = $node
+    rust        = $rust
+    powershell  = $ps
+}
+
+# --- Path layout facts ---------------------------------------------------
+$project = [System.IO.Path]::GetFullPath((Resolve-Path $ProjectRoot).Path)
+$result.paths = [ordered]@{
+    space_in_path    = $project.Contains(" ")
+    non_ascii_in_path = ($project.ToCharArray() | Where-Object { [int]$_ -gt 127 } | Measure-Object).Count -gt 0
+    project_root_sanitized = (Split-Path $project -Leaf)   # leaf only; no full private path
+}
+
+# --- Port availability ---------------------------------------------------
+$result.ports = [ordered]@{}
+foreach ($port in @(8000, 8001, 9000, 4444, 9515)) {
+    $result.ports[$port.ToString()] = [ordered]@{ port = $port; available = (Test-PortAvailable $port) }
+}
+
+# --- Console encoding ----------------------------------------------------
+$result.encoding = [ordered]@{
+    console_codepage = [Console]::OutputEncoding.CodePage
+    utf8_default     = ([Console]::OutputEncoding.WebName -eq "utf-8")
+}
+
+# --- Writable directories (project-local only) ---------------------------
+$candidates = @(
+    @{ label = "project_root"; path = $project },
+    @{ label = "runtime_cache"; path = (Join-Path $project ".hermes/task-runtime") }
+)
+$result.writable = @()
+foreach ($c in $candidates) {
+    $target = $c.path
+    $writable = $false
+    try {
+        New-Item -ItemType Directory -Path $target -Force -ErrorAction Stop | Out-Null
+        $probe = Join-Path $target (".doctor_probe_" + [Guid]::NewGuid().ToString("N") + ".tmp")
+        Set-Content -Path $probe -Value "x" -ErrorAction Stop | Out-Null
+        Remove-Item -Path $probe -Force -ErrorAction Stop
+        $writable = $true
+    } catch {
+        $writable = $false
+    }
+    $result.writable += [ordered]@{
+        label     = $c.label
+        path      = (Split-Path $target -Leaf)   # sanitized leaf only
+        writable  = $writable
+    }
+}
+
+# --- Overall health ------------------------------------------------------
+$required = @("python")
+$missing = @($required | Where-Object { -not $result.toolchain.$_.present })
+$result.healthy = ($missing.Count -eq 0)
+
+$result | ConvertTo-Json -Depth 6
diff --git a/tests/test_doctor_windows.py b/tests/test_doctor_windows.py
new file mode 100644
index 0000000..a31322c
--- /dev/null
+++ b/tests/test_doctor_windows.py
@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+DOCTOR = ROOT / "scripts" / "doctor_windows.ps1"
+
+
+def _pwsh_available() -> bool:
+    return shutil.which("pwsh") is not None
+
+
+def _run_doctor(project_root: Path | None = None) -> subprocess.CompletedProcess:
+    cmd = ["pwsh", "-NoProfile", "-File", str(DOCTOR)]
+    if project_root is not None:
+        cmd += ["-ProjectRoot", str(project_root)]
+    return subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+
+
+def test_doctor_script_present() -> None:
+    assert DOCTOR.exists()
+    assert DOCTOR.read_text(encoding="utf-8").startswith("#requires -Version 7.0")
+
+
+def test_doctor_output_is_structured_json() -> None:
+    if not _pwsh_available():
+        return
+    result = _run_doctor()
+    assert result.returncode == 0, result.stderr
+    payload = json.loads(result.stdout)
+    assert payload["schema_version"] == "axw.007a.v1"
+    assert "toolchain" in payload
+    assert "paths" in payload
+    assert "ports" in payload
+    assert "encoding" in payload
+    assert "writable" in payload
+    assert "healthy" in payload
+
+
+def test_doctor_never_emits_absolute_private_path() -> None:
+    """AXW-007A: output must not leak absolute project or home paths; only the
+    sanitized leaf and facts are allowed.
+    """
+    if not _pwsh_available():
+        return
+    result = _run_doctor()
+    assert result.returncode == 0, result.stderr
+    payload = json.loads(result.stdout)
+    raw = result.stdout
+
+    # project_root and writable paths must be leaf-only, never an absolute drive
+    # path that could reveal the local checkout location.
+    assert ":" not in payload["paths"]["project_root_sanitized"]
+    for entry in payload["writable"]:
+        assert ":" not in entry["path"], f"leaked absolute path: {entry['path']}"
+    # No Windows drive letters should appear anywhere in the JSON output.
+    assert "C:\\" not in raw and "D:\\" not in raw
+
+
+def test_doctor_detects_python_presence() -> None:
+    if not _pwsh_available():
+        return
+    result = _run_doctor()
+    payload = json.loads(result.stdout)
+    # On a dev machine python is expected; the contract is that the field exists
+    # and is a boolean, regardless of the actual value.
+    assert isinstance(payload["toolchain"]["python"]["present"], bool)
+    assert isinstance(payload["healthy"], bool)
+
+
+def test_doctor_sanitizes_writable_probe() -> None:
+    """The doctor must not leave probe files behind in the project root."""
+    if not _pwsh_available():
+        return
+    before = {p.name for p in ROOT.glob(".doctor_probe_*.tmp")}
+    _run_doctor(project_root=ROOT)
+    after = {p.name for p in ROOT.glob(".doctor_probe_*.tmp")}
+    assert after <= before
+
+
+def test_doctor_accepts_custom_project_root_without_touching_source() -> None:
+    if not _pwsh_available():
+        return
+    import tempfile
+
+    with tempfile.TemporaryDirectory() as tmp:
+        result = _run_doctor(project_root=Path(tmp))
+        assert result.returncode == 0, result.stderr
+        payload = json.loads(result.stdout)
+        assert payload["schema_version"] == "axw.007a.v1"

From 7b7df254286df7f4fee73fdf6f500a2f9e4a7f55 Mon Sep 17 00:00:00 2001
From: DTALEX66 <DTALEX66@users.noreply.github.com>
Date: Sun, 9 Aug 2026 22:24:11 +0800
Subject: [PATCH 3/8] feat(ingestion): add RawAsset-first immutable store
 (AXW-012A)

Persist original bytes immutably (SHA-256 content-addressed) before any
conversion. A failed converter retains the original plus a durable failure
record. Failure-injection tests prove no original is lost across value/OS/
store/interrupt/generic failures. Default root is the project's ignored
.hermes/task-runtime/raw-assets.
---
 app/ingestion/raw_asset.py | 140 +++++++++++++++++++++++++++++++++++++
 tests/test_raw_asset.py    | 117 +++++++++++++++++++++++++++++++
 2 files changed, 257 insertions(+)
 create mode 100644 app/ingestion/raw_asset.py
 create mode 100644 tests/test_raw_asset.py

diff --git a/app/ingestion/raw_asset.py b/app/ingestion/raw_asset.py
new file mode 100644
index 0000000..250a535
--- /dev/null
+++ b/app/ingestion/raw_asset.py
@@ -0,0 +1,140 @@
+"""AXW-012A: RawAsset-first minimal store.
+
+Contract: original bytes are persisted immutably (content-addressed by
+SHA-256) BEFORE any conversion runs; a failed conversion must still retain the
+original plus a durable failure record. Failure injection must never lose the
+original.
+
+The default storage root lives under the project's ignored `.hermes/`
+runtime boundary; it never touches the source vault or a tracked path.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class RawAssetStoreError(ValueError):
+    """Raised on invalid input or an unrecoverable storage failure."""
+
+
+def _sha256(b: bytes) -> str:
+    return hashlib.sha256(b).hexdigest()
+
+
+def _default_root() -> Path:
+    # Prefer HERMES_PROJECT_RUNTIME_ROOT if provided by the project data
+    # wrapper; otherwise fall back to the repository .hermes/task-runtime.
+    env_root = os.environ.get("HERMES_PROJECT_RUNTIME_ROOT")
+    if env_root:
+        return Path(env_root) / "raw-assets"
+    # Repository root = <repo>/app/ingestion/raw_asset.py -> parents[2]
+    repo_root = Path(__file__).resolve().parents[2]
+    return repo_root / ".hermes" / "task-runtime" / "raw-assets"
+
+
+@dataclass(frozen=True)
+class RawAssetRecord:
+    sha256: str
+    size_bytes: int
+    source_name: str
+    converted: str | None
+    error: str | None = None
+
+    @property
+    def original_sha(self) -> str:
+        return self.sha256
+
+
+class RawAssetStore:
+    """Content-addressed immutable store for original source bytes."""
+
+    def __init__(self, root: Path | None = None) -> None:
+        self.root = (root or _default_root()).resolve()
+        self.root.mkdir(parents=True, exist_ok=True)
+        self._failures_dir = self.root / "_failures"
+        self._failures_dir.mkdir(parents=True, exist_ok=True)
+
+    def _original_path(self, digest: str) -> Path:
+        return self.root / digest
+
+    def _failure_path(self, digest: str) -> Path:
+        return self._failures_dir / f"{digest}.json"
+
+    def has(self, digest: str) -> bool:
+        return self._original_path(digest).exists()
+
+    def has_failure(self, digest: str) -> bool:
+        return self._failure_path(digest).exists()
+
+    def resolve(self, digest: str) -> Path:
+        p = self._original_path(digest)
+        if not p.exists():
+            raise RawAssetStoreError(f"raw asset not present: {digest}")
+        return p
+
+    def store_original(self, blob: bytes, source_name: str) -> RawAssetRecord:
+        """Persist the original bytes immutably and return a record. Raises on
+        empty input so empty content can never masquerade as a source asset."""
+        if not source_name.strip():
+            raise RawAssetStoreError("source_name is required")
+        if not blob:
+            raise RawAssetStoreError("empty original bytes cannot be stored")
+        digest = _sha256(blob)
+        dest = self._original_path(digest)
+        # Immutable write: only write when the content-addressed file is absent,
+        # and verify the hash after writing (no silent partial/corrupt writes).
+        if not dest.exists():
+            dest.write_bytes(blob)
+            if _sha256(dest.read_bytes()) != digest:
+                raise RawAssetStoreError("raw asset hash mismatch after write")
+        return RawAssetRecord(
+            sha256=digest,
+            size_bytes=len(blob),
+            source_name=source_name,
+            converted=None,
+        )
+
+    def _record_failure(self, digest: str, source_name: str, error: str) -> None:
+        payload = {
+            "sha256": digest,
+            "source_name": source_name,
+            "error": error,
+            "original_retained": True,
+        }
+        fp = self._failure_path(digest)
+        if not fp.exists():
+            fp.write_text(json.dumps(payload, ensure_ascii=True, indent=2), encoding="utf-8")
+
+
+def preserve_then_convert(
+    store: RawAssetStore,
+    blob: bytes,
+    source_name: str,
+    convert: Callable[[bytes], str],
+) -> RawAssetRecord:
+    """Persist the original first, then convert. On any converter failure the
+    original is retained and a durable failure record is written. Returns a
+    record whose `converted` is None and `error` populated on failure."""
+    original = store.store_original(blob, source_name)
+    try:
+        converted = convert(blob)
+    except BaseException as exc:  # noqa: BLE001 — we must not lose the original
+        store._record_failure(original.sha256, source_name, str(exc))
+        return RawAssetRecord(
+            sha256=original.sha256,
+            size_bytes=original.size_bytes,
+            source_name=source_name,
+            converted=None,
+            error=str(exc),
+        )
+    return RawAssetRecord(
+        sha256=original.sha256,
+        size_bytes=original.size_bytes,
+        source_name=source_name,
+        converted=converted,
+    )
diff --git a/tests/test_raw_asset.py b/tests/test_raw_asset.py
new file mode 100644
index 0000000..539f98e
--- /dev/null
+++ b/tests/test_raw_asset.py
@@ -0,0 +1,117 @@
+"""AXW-012A: RawAsset-first minimal implementation tests.
+
+Contract: the original bytes must be stored immutably (content-addressed by
+SHA-256) BEFORE any conversion runs; a failed conversion must still retain the
+original and a failure record; failure injection must prove no original loss.
+"""
+from __future__ import annotations
+
+import hashlib
+
+import pytest
+
+from app.ingestion.raw_asset import (
+    RawAssetStore,
+    RawAssetStoreError,
+    preserve_then_convert,
+)
+
+
+def _sha256(b: bytes) -> str:
+    return hashlib.sha256(b).hexdigest()
+
+
+def test_store_original_immutably_and_hash(tmp_path) -> None:
+    store = RawAssetStore(root=tmp_path / "raw")
+    blob = b"# original markdown\nfirst line"
+    record = store.store_original(blob, source_name="a.md")
+
+    assert record.sha256 == _sha256(blob)
+    assert record.size_bytes == len(blob)
+    # Content-addressed path is derived from the digest and exists on disk.
+    stored = store.resolve(record.sha256)
+    assert stored.exists()
+    assert stored.read_bytes() == blob
+    assert not record.converted
+
+
+def test_original_is_stored_before_conversion(tmp_path, monkeypatch) -> None:
+    """The original must be persisted before the converter is invoked."""
+    store = RawAssetStore(root=tmp_path / "raw")
+    blob = b"# converted later\nbody"
+    seen = {"original_sha": None, "stored_before": False}
+
+    def fake_convert(raw: bytes) -> str:
+        seen["stored_before"] = store.has(seen["original_sha"])
+        return "# converted"
+
+    seen["original_sha"] = _sha256(blob)
+    result = preserve_then_convert(store, blob, "b.md", fake_convert)
+    assert result.converted == "# converted"
+    assert seen["stored_before"] is True
+    assert store.has(_sha256(blob))
+
+
+def test_failed_conversion_keeps_original_and_records_failure(tmp_path) -> None:
+    store = RawAssetStore(root=tmp_path / "raw")
+    blob = b"# fragile content"
+
+    def broken_convert(raw: bytes) -> str:
+        raise RuntimeError("converter exploded")
+
+    result = preserve_then_convert(store, blob, "c.md", broken_convert)
+    assert result.converted is None
+    assert result.error == "converter exploded"
+    assert result.original_sha == _sha256(blob)
+    # Original must still be on disk after the failure.
+    assert store.has(_sha256(blob))
+    # Failure must be recorded.
+    assert store.has_failure(result.original_sha)
+
+
+def test_failure_injection_proves_no_original_loss(tmp_path) -> None:
+    """Inject failure at multiple points; the original must survive every one."""
+    store = RawAssetStore(root=tmp_path / "raw")
+    blob = b"\x00\x01\x02 binary-ish original"
+
+    for attempt in range(5):
+        if attempt == 0:
+            conv = lambda raw: (_ for _ in ()).throw(ValueError("boom A"))  # noqa: E731
+        elif attempt == 1:
+            def conv1(raw):
+                raise OSError("disk hiccup")
+            conv = conv1
+        elif attempt == 2:
+            def conv2(raw):
+                raise RawAssetStoreError("store rejected")
+            conv = conv2
+        elif attempt == 3:
+            def conv3(raw):
+                raise KeyboardInterrupt("interrupted")
+            conv = conv3
+        else:
+            def conv4(raw):
+                raise Exception("generic")  # noqa: BLE001
+            conv = conv4
+
+        result = preserve_then_convert(store, blob, f"f{attempt}.bin", conv)
+        assert result.converted is None
+        assert store.has(_sha256(blob)), f"original lost on attempt {attempt}"
+        assert store.has_failure(result.original_sha)
+
+
+def test_store_rejects_empty_source_and_empty_blob(tmp_path) -> None:
+    store = RawAssetStore(root=tmp_path / "raw")
+    with pytest.raises(RawAssetStoreError):
+        store.store_original(b"", source_name="x.md")
+    with pytest.raises(RawAssetStoreError):
+        store.store_original(b"data", source_name="")
+
+
+def test_store_defaults_to_project_ignored_runtime_root() -> None:
+    store = RawAssetStore()
+    # Default root must live under the project's ignored runtime directory,
+    # never under the user home or a repo-tracked path.
+    root = str(store.root).replace("\\", "/")
+    assert "/.hermes/" in root
+    assert root.endswith("/task-runtime/raw-assets")

From 9ff5ba6e8b22b3671e3ddf542087598c729aafe7 Mon Sep 17 00:00:00 2001
From: DTALEX66 <DTALEX66@users.noreply.github.com>
Date: Sun, 9 Aug 2026 22:25:05 +0800
Subject: [PATCH 4/8] fix(ci): classify dependency and format-parser changes
 (AXW-003C)

requirements.txt was an unknown path that forced full-qualification; it now
maps to python-compat and triggers wheel-smoke + py-compat. Format parsers
(pdf.py, multi_format.py) now trigger wheel-smoke so parser changes rebuild
and smoke the installed wheel. Covered by two new path-mutation regression
tests.
---
 .worklab/project-validation.v1.yaml | 11 ++++++++++-
 tests/test_ci_classifier.py         | 25 +++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/.worklab/project-validation.v1.yaml b/.worklab/project-validation.v1.yaml
index 619b17c..5246669 100644
--- a/.worklab/project-validation.v1.yaml
+++ b/.worklab/project-validation.v1.yaml
@@ -88,13 +88,22 @@ risk_classes:
     gates: [static, lint, py-primary, wheel-smoke]
 
   - id: python-compat
-    description: Public Python contracts and dependency matrix
+    description: Public Python contracts, dependency matrix and requirements
     paths:
       - pyproject.toml
+      - requirements.txt
       - uv.lock
       - "shared-contracts/**"
     gates: [static, lint, py-compat, wheel-smoke]
 
+  - id: format-parser
+    description: Format parsers / conversion engines that affect the installed wheel
+    paths:
+      - "app/ingestion/pdf.py"
+      - "app/ingestion/multi_format.py"
+      - "app/ingestion/*.py"
+    gates: [static, lint, py-primary, wheel-smoke]
+
   - id: windows-runtime
     description: Windows storage, migration, process, path handling
     paths:
diff --git a/tests/test_ci_classifier.py b/tests/test_ci_classifier.py
index e54bd03..8404760 100644
--- a/tests/test_ci_classifier.py
+++ b/tests/test_ci_classifier.py
@@ -104,6 +104,31 @@ def test_wheel_packaging_requires_wheel_smoke() -> None:
     assert "wheel-smoke" in plan["required_gates"]
 
 
+def test_requirements_change_triggers_wheel_and_compat_not_full_scan() -> None:
+    """AXW-003C: a requirements.txt change is a dependency change that must
+    rebuild and smoke the wheel and the compat matrix. It must NOT degrade into
+    a blanket full-qualification scan, and it must NOT be treated as unknown.
+    """
+    plan = _classify(["requirements.txt"])
+    assert plan["full_qualification"] is False, plan
+    assert "wheel-smoke" in plan["required_gates"]
+    assert "py-compat" in plan["required_gates"]
+    assert plan["unknown_paths"] == []
+
+
+def test_parser_change_triggers_wheel_smoke() -> None:
+    """AXW-003C: changing a format parser (pdf/multi-format) affects what the
+    installed wheel can convert, so the wheel must be rebuilt and smoked. The
+    plain py-primary-only classification would miss install-state regressions.
+    """
+    for path in ("app/ingestion/pdf.py", "app/ingestion/multi_format.py"):
+        plan = _classify([path])
+        assert plan["full_qualification"] is False, (path, plan)
+        assert "py-primary" in plan["required_gates"]
+        assert "wheel-smoke" in plan["required_gates"], f"{path} missing wheel-smoke"
+        assert plan["unknown_paths"] == [], (path, plan["unknown_paths"])
+
+
 def test_ci_policy_change_forces_full() -> None:
     plan = _classify([".github/workflows/ci.yml"])
     assert "full-qualification" not in plan["required_gates"]  # logical profile

From d7acc8b34d7c3594a18a96669921263166cc9e66 Mon Sep 17 00:00:00 2001
From: DTALEX66 <DTALEX66@users.noreply.github.com>
Date: Sun, 9 Aug 2026 22:26:50 +0800
Subject: [PATCH 5/8] fix(pdf): enable markitdown[pdf] for installed PDF
 extraction (AXW-012B)

The product wheel and ci-adapters group declared bare markitdown>=0.1, so the
installed runtime had no pdfminer/pdfplumber backend and real PDF conversion
failed with MissingDependencyException. Declare markitdown[pdf]>=0.1 and sync
requirements.txt and uv.lock (adds pdfminer-six, pdfplumber, pypdfium2). A
real-binary PDF extraction test replaces the old text-disguised-as-PDF check
and passes through the product convert path under ci-adapters.
---
 pyproject.toml               |  4 +--
 requirements.txt             |  2 +-
 tests/test_pdf_extraction.py | 61 +++++++++++++++++++++++++++++++
 uv.lock                      | 70 +++++++++++++++++++++++++++++++++---
 4 files changed, 130 insertions(+), 7 deletions(-)
 create mode 100644 tests/test_pdf_extraction.py

diff --git a/pyproject.toml b/pyproject.toml
index 61e2f79..4c2f508 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -24,7 +24,7 @@ dependencies = [
     "sqlite-vec>=0.1.6",
     "loguru>=0.7",
     "structlog>=24.0",
-    "markitdown>=0.1",
+    "markitdown[pdf]>=0.1",
     "trafilatura>=1.6",
     "networkx>=3.0",
     "litellm==1.91.0",
@@ -61,7 +61,7 @@ ci = [
     "uvicorn[standard]>=0.22",
 ]
 ci-adapters = [
-    "markitdown>=0.1",
+    "markitdown[pdf]>=0.1",
     "newspaper4k>=0.9",
     "readabilipy>=0.3",
     "trafilatura>=1.6",
diff --git a/requirements.txt b/requirements.txt
index 4c219a0..e7a02e4 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -11,7 +11,7 @@ apscheduler>=3.10
 sqlite-vec>=0.1.6
 loguru>=0.7
 structlog>=24.0
-markitdown>=0.1
+markitdown[pdf]>=0.1
 trafilatura>=1.6
 networkx>=3.0
 litellm==1.91.0
diff --git a/tests/test_pdf_extraction.py b/tests/test_pdf_extraction.py
new file mode 100644
index 0000000..3b0d507
--- /dev/null
+++ b/tests/test_pdf_extraction.py
@@ -0,0 +1,61 @@
+"""AXW-012B: PDF extraction must work against a real PDF in the product path.
+
+The old `test_pdf_uses_markitdown` wrote plain text into a `.pdf` filename,
+which is a text-disguised-as-PDF contract test, not conversion evidence. This
+test drives a genuine minimal PDF binary (a valid one-page PDF with a text
+stream) through the product's convert path under the ci-adapters group that
+carries markitdown[pdf].
+"""
+
+from __future__ import annotations
+
+# A minimal but real single-page PDF containing the words "Evidence Driven
+# Learning" as a text stream. This is valid PDF binary, not a renamed text file.
+REAL_PDF = (
+    b"%PDF-1.4\n"
+    b"1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n"
+    b"2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1>>endobj\n"
+    b"3 0 obj<</Type/Page/Parent 2 0 R/MediaBox[0 0 612 792]/Contents 4 0 R/Resources<</Font<</F1 5 0 R>>>>>>endobj\n"
+    b"4 0 obj<</Length 60>>stream\n"
+    b"BT /F1 24 Tf 72 720 Td (Evidence Driven Learning) Tj ET\n"
+    b"endstream endobj\n"
+    b"5 0 obj<</Type/Font/Subtype/Type1/BaseFont/Helvetica>>endobj\n"
+    b"xref\n"
+    b"0 6\n"
+    b"0000000000 65535 f \n"
+    b"0000000009 00000 n \n"
+    b"0000000058 00000 n \n"
+    b"0000000115 00000 n \n"
+    b"0000000245 00000 n \n"
+    b"0000000347 00000 n \n"
+    b"trailer<</Size 6/Root 1 0 R>>\n"
+    b"startxref\n"
+    b"410\n"
+    b"%%EOF\n"
+)
+
+
+def test_pdf_is_real_binary_not_disguised_text() -> None:
+    # Guard against accidentally reverting to a text-disguised-PDF fixture.
+    assert REAL_PDF.startswith(b"%PDF-")
+    assert b"Evidence Driven Learning" in REAL_PDF
+
+
+def test_product_convert_path_extracts_real_pdf(tmp_path) -> None:
+    from app.ingestion.multi_format import convert_file
+
+    f = tmp_path / "real.pdf"
+    f.write_bytes(REAL_PDF)
+
+    content, engine = convert_file(str(f))
+    assert engine == "markitdown"
+    assert "Evidence Driven Learning" in content
+
+
+def test_pdf_requires_pdf_backend_present() -> None:
+    """Under ci-adapters (markitdown[pdf]) the PDF backend must be importable;
+    without it, installed-wheel PDF conversion is unverified."""
+    import importlib
+
+    for mod in ("pdfminer", "pdfplumber"):
+        assert importlib.util.find_spec(mod) is not None, f"missing {mod}"
diff --git a/uv.lock b/uv.lock
index 8cee34e..b49aa8d 100644
--- a/uv.lock
+++ b/uv.lock
@@ -627,7 +627,7 @@ dependencies = [
     { name = "fastapi" },
     { name = "litellm" },
     { name = "loguru" },
-    { name = "markitdown" },
+    { name = "markitdown", extra = ["pdf"] },
     { name = "networkx" },
     { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
     { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
@@ -698,7 +698,7 @@ ci = [
     { name = "uvicorn", extra = ["standard"] },
 ]
 ci-adapters = [
-    { name = "markitdown" },
+    { name = "markitdown", extra = ["pdf"] },
     { name = "newspaper4k" },
     { name = "readabilipy" },
     { name = "trafilatura" },
@@ -716,7 +716,7 @@ requires-dist = [
     { name = "langfuse", marker = "extra == 'ingestion'", specifier = ">=4.0" },
     { name = "litellm", specifier = "==1.91.0" },
     { name = "loguru", specifier = ">=0.7" },
-    { name = "markitdown", specifier = ">=0.1" },
+    { name = "markitdown", extras = ["pdf"], specifier = ">=0.1" },
     { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.8" },
     { name = "networkx", specifier = ">=3.0" },
     { name = "numpy", specifier = ">=1.24" },
@@ -767,7 +767,7 @@ ci = [
     { name = "uvicorn", extras = ["standard"], specifier = ">=0.22" },
 ]
 ci-adapters = [
-    { name = "markitdown", specifier = ">=0.1" },
+    { name = "markitdown", extras = ["pdf"], specifier = ">=0.1" },
     { name = "newspaper4k", specifier = ">=0.9" },
     { name = "readabilipy", specifier = ">=0.3" },
     { name = "trafilatura", specifier = ">=1.6" },
@@ -2030,6 +2030,12 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9e/30/8031f183ee86ea8ac4e7ea1296bab4cca1bee2fd036a26df69764eb7ca74/markitdown-0.1.6-py3-none-any.whl", hash = "sha256:07b2d5bf87b5c53e13a9f2fdc440df8ccc85e26f40c1e557781727b700049775", size = 70032, upload-time = "2026-05-26T22:44:03.209Z" },
 ]
 
+[package.optional-dependencies]
+pdf = [
+    { name = "pdfminer-six" },
+    { name = "pdfplumber" },
+]
+
 [[package]]
 name = "markupsafe"
 version = "3.0.3"
@@ -2669,6 +2675,33 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" },
 ]
 
+[[package]]
+name = "pdfminer-six"
+version = "20260107"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "charset-normalizer" },
+    { name = "cryptography" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/34/a4/5cec1112009f0439a5ca6afa8ace321f0ab2f48da3255b7a1c8953014670/pdfminer_six-20260107.tar.gz", hash = "sha256:96bfd431e3577a55a0efd25676968ca4ce8fd5b53f14565f85716ff363889602", size = 8512094, upload-time = "2026-01-07T13:29:12.937Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/8b/28c4eaec9d6b036a52cb44720408f26b1a143ca9bce76cc19e8f5de00ab4/pdfminer_six-20260107-py3-none-any.whl", hash = "sha256:366585ba97e80dffa8f00cebe303d2f381884d8637af4ce422f1df3ef38111a9", size = 6592252, upload-time = "2026-01-07T13:29:10.742Z" },
+]
+
+[[package]]
+name = "pdfplumber"
+version = "0.11.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pdfminer-six" },
+    { name = "pillow" },
+    { name = "pypdfium2" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/05/56/6f450312ba05a27d7713b73857c1a25100dbda04fbc1331b13fb227a607d/pdfplumber-0.11.10.tar.gz", hash = "sha256:b95b2d28c66efb0a794a83b88c6c6aea5987532a445d20a1cbcfa657022e6e57", size = 102892, upload-time = "2026-06-15T03:31:31.035Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/9a/07d658e1e7fad860f1c541ab941348125dbdab773be3a0afaf32361866c7/pdfplumber-0.11.10-py3-none-any.whl", hash = "sha256:7741ea81bf165b474b153e6789d10d18e06b6ddcf3ec84289c3ef2fed6802580", size = 60047, upload-time = "2026-06-15T03:31:29.702Z" },
+]
+
 [[package]]
 name = "pillow"
 version = "12.3.0"
@@ -3161,6 +3194,35 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/54/18/1dd71c9b43192ab83f1d531ad6002dc81108ac36c475f79fb7a295abe2f4/pyopenssl-26.3.0-py3-none-any.whl", hash = "sha256:46367f8f66b92271e6d218da9c87607e1ef5a0bc5c8dea5bb3db82f395c385a3", size = 56008, upload-time = "2026-06-12T20:28:05.999Z" },
 ]
 
+[[package]]
+name = "pypdfium2"
+version = "5.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/db/42/0b51bdf50ccf13f3deb3209ca996179a49761dc191748469cf0de55b0055/pypdfium2-5.12.1.tar.gz", hash = "sha256:d0e0648fb2e28f50efcd1ec0a5a18ced9f4d66b2c227fae9b603f0a883b2d13f", size = 274428, upload-time = "2026-07-17T10:01:22.713Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/09/7e/bd8df53b1131c582f6646372047b49162032bd01628d49b9a60cd94d2181/pypdfium2-5.12.1-py3-none-android_23_arm64_v8a.whl", hash = "sha256:05bab9b1ba2de7fc299ae2af25cb9c8a0543bc8bb893e879fe8c9ba8310e9ce4", size = 3392276, upload-time = "2026-07-17T10:00:47.376Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/13/a2b71e17b0439d2af78c817a381e3557371c6c56098581da8485aef65ea6/pypdfium2-5.12.1-py3-none-android_23_armeabi_v7a.whl", hash = "sha256:d4ee061e566a6422b660cdddaaa799a2d1cbf2f016921bcaf24d61426d01d942", size = 2848776, upload-time = "2026-07-17T10:00:49.09Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/a8/d7a61700db3022792b28bce5264be90a7d2e7104998362af6b93766f50b2/pypdfium2-5.12.1-py3-none-macosx_13_0_arm64.whl", hash = "sha256:66a9ed40d70a5d728cd42148fecb9d7a0917c6161d6bb67c844093a4ed1df089", size = 3480243, upload-time = "2026-07-17T10:00:50.674Z" },
+    { url = "https://files.pythonhosted.org/packages/01/2c/d7a38fad74b6da0947cf8763aee0f8e6c9d3c12fc8e137aa615f7f8ae76c/pypdfium2-5.12.1-py3-none-macosx_13_0_x86_64.whl", hash = "sha256:847378a5ab41332998b2621b21bab2e96dc8c3eff36a08bce26695b964163983", size = 3643490, upload-time = "2026-07-17T10:00:52.236Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/29/aca739676323558595fcf8cdc8d7939d2b25aaaa6f538e829f1fee938cdd/pypdfium2-5.12.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6eabf028ad8e7bc7811c9acf3a72718c180569b624b844d2c6cc974609784275", size = 3649734, upload-time = "2026-07-17T10:00:53.776Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/e0/e4ecc05f4f1a11d11c8d684a24b2fc8be8207f341be985dac301caa4f6aa/pypdfium2-5.12.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7857cfa6642ec5a09db12ff8f5cf6b6494585b5e3a605399fddc4fb862837b63", size = 3380828, upload-time = "2026-07-17T10:00:55.377Z" },
+    { url = "https://files.pythonhosted.org/packages/17/1b/c94c9d486791276e736350917a11fe2cf3acba2c6c7f03f9ac0d51f8952a/pypdfium2-5.12.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:05bfa20a08a96584253bbe38b60e13f81a037eac31c5579e607ec1480ad25dbf", size = 3777202, upload-time = "2026-07-17T10:00:57.212Z" },
+    { url = "https://files.pythonhosted.org/packages/14/aa/7f81f0c035fc32850dfab9daf78530814f215be226dad7491e3caa0a3e8c/pypdfium2-5.12.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9f059f7bdbdf4352eb83691071096940d769d6ae5930b8734237fdb1bd78fbc2", size = 4186083, upload-time = "2026-07-17T10:00:59.022Z" },
+    { url = "https://files.pythonhosted.org/packages/23/16/21420a6f2bc5f981299c336817dd5d72709dad5fda30ac38cbd5f0f7b372/pypdfium2-5.12.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e10cbf41b21233ec5e20adfc170cf60edd77abead86a97dc708fff55a8a886c7", size = 3701734, upload-time = "2026-07-17T10:01:00.952Z" },
+    { url = "https://files.pythonhosted.org/packages/36/a1/bb89f49e2b3ea3e945b67859d2ec6e73e722a83c006099c675692641e51d/pypdfium2-5.12.1-py3-none-manylinux_2_27_s390x.manylinux_2_28_s390x.whl", hash = "sha256:07eeebb2784f4cd38d386b924235df43217a397442796673296bb6efbdaad1d0", size = 4030403, upload-time = "2026-07-17T10:01:02.568Z" },
+    { url = "https://files.pythonhosted.org/packages/80/a7/cea5eb0c39e9c6fdf9853a3008bf021d08f962228073af90354b60c5ccdc/pypdfium2-5.12.1-py3-none-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5c3e6cbe43581af79526184643920ab03a9401a0c79f2226bea9d4d1e3d34008", size = 3994411, upload-time = "2026-07-17T10:01:04.25Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/43/5e470213b27c13b0d94d03d97fc3740507edadea1d1e2ce2049bfbec4aa0/pypdfium2-5.12.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:4648f0905441bcb141687ca2263bbf38a1aa056b943eef06019f91cff3e1da4a", size = 4993687, upload-time = "2026-07-17T10:01:05.811Z" },
+    { url = "https://files.pythonhosted.org/packages/db/da/af7972ca72f24ed720db6501333fd67bc66aa6aa5a5ec698551bd30ae62e/pypdfium2-5.12.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:bdff622181fab64f32328591c9c8287cdc745c9a1f2afc26ca3feba39e3e6645", size = 4534560, upload-time = "2026-07-17T10:01:07.291Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/63/06a7f2cd691f7e336cbc53fd65453fee516042c8ddb016bc50d1cd2bed45/pypdfium2-5.12.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:236dbdc88aa54f14b27937ccb2ebe3dcf08c10dbb8652f432ea982dc9af39732", size = 5237681, upload-time = "2026-07-17T10:01:08.997Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/f5/937b080671758ab0b3d3d69b2657006682e4c6a0134b36774be4ed1afcfb/pypdfium2-5.12.1-py3-none-musllinux_1_2_ppc64le.whl", hash = "sha256:9c8856ce7dd77a7827476c7d75afe1197d6cd505f5cb4167b6aacf661f3f8ea5", size = 5143027, upload-time = "2026-07-17T10:01:10.69Z" },
+    { url = "https://files.pythonhosted.org/packages/32/02/094632700c24728fa443dc89d9d1c6e4fc05bb00778b22e8482fdb133da0/pypdfium2-5.12.1-py3-none-musllinux_1_2_riscv64.whl", hash = "sha256:5f257bb40fa44ce9ba18d2c919777dbd3f16bf22548b1d68fd56c7c92f1de530", size = 4647048, upload-time = "2026-07-17T10:01:12.559Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/d0/12d84bf55a4fcf2c0ed242afc94168933194f672067e1d162aa60a8e4426/pypdfium2-5.12.1-py3-none-musllinux_1_2_s390x.whl", hash = "sha256:974082344172da76a5c3c0782eaedfe6069dbe88db77d8c671ef36b61e9b14e2", size = 5088747, upload-time = "2026-07-17T10:01:14.42Z" },
+    { url = "https://files.pythonhosted.org/packages/92/9c/92a460bac1f6cfd6f96251802b3098a804fb251dfe0b5eb004ede958ae0e/pypdfium2-5.12.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:715ae16b34ea1d64884d58800155179ba700e9ea65a2f583b020666acd2bfb12", size = 5049695, upload-time = "2026-07-17T10:01:15.961Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/67/53c61d366222550220b42a9212131407f49d3dbcf050178c620bf80fa899/pypdfium2-5.12.1-py3-none-win32.whl", hash = "sha256:e5358d2ce4ebc5c899aab1df9ca5d215357244e9168aa443225d3c1e649c7eac", size = 3725466, upload-time = "2026-07-17T10:01:17.773Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/c3/08b62718faf2f6b6aa49207626e3113ff3ec1b3cd076c0ef8fd852f0e57c/pypdfium2-5.12.1-py3-none-win_amd64.whl", hash = "sha256:9609be73a6701a68f29dffe0335f7a2e4b3ba581542ed65d35d49f761a4600ca", size = 3859845, upload-time = "2026-07-17T10:01:19.417Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/d5/ad551e55790134c8bc87ea16e0866a3721def0620fbfa19112c8ad4a25a6/pypdfium2-5.12.1-py3-none-win_arm64.whl", hash = "sha256:afc0b7e0c975a429abc75875209ce17b66d749f6ac5cbe8ba72470e83901e304", size = 3674605, upload-time = "2026-07-17T10:01:21.008Z" },
+]
+
 [[package]]
 name = "pyreadline3"
 version = "3.5.6"

From b35aae0ca4478f12cfff9968d954f87e30bf29cf Mon Sep 17 00:00:00 2001
From: DTALEX66 <DTALEX66@users.noreply.github.com>
Date: Sun, 9 Aug 2026 22:28:10 +0800
Subject: [PATCH 6/8] fix(release): sync dependency lock digest after
 markitdown[pdf] (AXW-009B)

AXW-012B changed uv.lock (added pdfminer-six, pdfplumber, pypdfium2). The
release-manifest dependency_lock.digest must match the locked tree for a
unified version identity. Bump digest to 9916e6db... and revision to 5.
---
 app/release-manifest.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/app/release-manifest.json b/app/release-manifest.json
index 2d1eca1..49742f1 100644
--- a/app/release-manifest.json
+++ b/app/release-manifest.json
@@ -24,9 +24,9 @@
   "dependency_lock": {
     "path": "uv.lock",
     "algorithm": "sha256",
-    "digest": "e103c5f9a46ca2e11d50460b610de648978b62e60f53bdd7dd97d81fcf121cf8",
+    "digest": "9916e6dba6d152cff045abf188218a0a3a533a786b3c3061738dc3a128aa4268",
     "format_version": 1,
-    "revision": 4
+    "revision": 5
   },
   "migrations": {
     "owners": [

From 35066f8c99c8767f0a1944ec573333791c74572f Mon Sep 17 00:00:00 2001
From: DTALEX66 <DTALEX66@users.noreply.github.com>
Date: Sun, 9 Aug 2026 22:36:08 +0800
Subject: [PATCH 7/8] fix(test): align ci-adapters assertion with
 markitdown[pdf]

AXW-012B changed ci-adapters to markitdown[pdf]>=0.1; the runtime-policy
gate asserted the stale markitdown>=0.1. Update the expected requirement.
---
 tests/test_ci_a0_gates.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_ci_a0_gates.py b/tests/test_ci_a0_gates.py
index 17e1368..d7ea312 100644
--- a/tests/test_ci_a0_gates.py
+++ b/tests/test_ci_a0_gates.py
@@ -304,7 +304,7 @@ def test_runtime_policy_uses_python_311_floor_and_python_312_desktop() -> None:
     assert '"3.10"' not in test_job
     ci_adapters = project["dependency-groups"]["ci-adapters"]
     for requirement in (
-        "markitdown>=0.1",
+        "markitdown[pdf]>=0.1",
         "newspaper4k>=0.9",
         "readabilipy>=0.3",
         "trafilatura>=1.6",

From 39df7d263ef6ac6e8d5c2e07c2de64261fdaeda8 Mon Sep 17 00:00:00 2001
From: DTALEX66 <DTALEX66@users.noreply.github.com>
Date: Sun, 9 Aug 2026 23:01:42 +0800
Subject: [PATCH 8/8] test(workspace)+docs(notices): honest capability
 projection and PDF notices (AXW-010B/006C)

AXW-010B: assert status endpoint projects unimplemented capabilities
(asr/postgresql/qdrant/public_installer) as not_implemented, image_ocr as
dependency_required, and never claims a capability the runtime lacks.
AXW-006C: list markitdown[pdf] (pdfminer-six/pdfplumber/pypdfium2) in
THIRD_PARTY_NOTICES so bundled PDF dependencies are auditable.
---
 THIRD_PARTY_NOTICES.md      |  4 +++-
 tests/test_workspace_api.py | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 39 insertions(+), 1 deletion(-)

diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
index e67d539..a62613d 100644
--- a/THIRD_PARTY_NOTICES.md
+++ b/THIRD_PARTY_NOTICES.md
@@ -11,7 +11,9 @@ The release dependency contract is `pyproject.toml` plus the exact resolved
 
 `fastapi`, `python-multipart`, `uvicorn`, `pydantic`, `numpy`, `requests`,
 `pyyaml`, `beautifulsoup4`, `defusedxml`, `apscheduler`, `sqlite-vec`, `loguru`,
-`structlog`, `markitdown`, `trafilatura`, `networkx`, `litellm`, `pillow`, and
+`structlog`, `markitdown[pdf]` (with `pdfminer-six`, `pdfplumber`, and
+`pypdfium2` for PDF extraction), `trafilatura`, `networkx`, `litellm`,
+`pillow`, and
 `pytesseract`.
 
 Optional or development groups additionally declare `setuptools`,
diff --git a/tests/test_workspace_api.py b/tests/test_workspace_api.py
index 23eb671..b17da20 100644
--- a/tests/test_workspace_api.py
+++ b/tests/test_workspace_api.py
@@ -1001,3 +1001,39 @@ def test_workspace_jobs_reads_live_wal_after_http_style_intake(monkeypatch, tmp_
         assert intake["job_id"]
     finally:
         writer.close()
+
+
+def test_workspace_capability_projection_is_honest(monkeypatch, tmp_path) -> None:
+    """AXW-010B: the status endpoint must project capabilities truthfully. Any
+    unimplemented capability must read not_implemented, never available, so a
+    route can never claim a capability the installed runtime does not provide.
+    """
+    from app.main import app
+    from app.workspace import router
+    from shared.migration_runner import MigrationOperator
+    from tests.test_phase5_mcs_closed_loop import _database
+
+    database = _database(tmp_path)
+    MigrationOperator(db_path=database, backup_dir=tmp_path / "workspace-backups").apply(
+        "workspace.sqlite"
+    )
+
+    monkeypatch.setattr(router, "DB_PATH", database)
+
+    response = TestClient(app).get("/workspace/api/status")
+    assert response.status_code == 200
+    caps = response.json()["capabilities"]
+
+    # ASR has no real engine -> must stay not_implemented (never available).
+    assert caps["asr_transcription"] == "not_implemented"
+    assert caps["postgresql_runtime"] == "not_implemented"
+    assert caps["qdrant_runtime"] == "not_implemented"
+    assert caps["public_installer"] == "not_implemented"
+    # Image OCR depends on an external Tesseract engine -> dependency_required.
+    assert caps["image_ocr"] == "dependency_required"
+    # Genuinely wired capabilities must read available.
+    assert caps["asynchronous_worker"] == "available"
+    assert caps["workspace_job_outbox_receipts"] == "available"
+    # Every capability value must be a recognized projection token.
+    allowed = {"available", "dependency_required", "not_implemented"}
+    assert all(caps[k] in allowed for k in caps)