release: finalize PaperForge v3 runtime

Author: QJHWC

.github/workflows/ci.yml

@@ -21,6 +21,11 @@ jobs:
         with:
           python-version: ${{ matrix.python }}
           cache: pip
+      - if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y bubblewrap
+          sudo chmod u+s "$(command -v bwrap)"
       - run: python -m pip install --upgrade pip
       - run: python -m pip install -r requirements-dev.txt
       - run: python -m pip check
@@ -33,3 +38,28 @@ jobs:
         run: python -m build
       - if: matrix.python == '3.11'
         run: python tools/verify_wheel.py dist/paperforge_research_os-3.0.0-py3-none-any.whl
+
+  real-compute-integration:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065
+        with:
+          python-version: "3.11"
+          cache: pip
+      - run: python -m pip install -r requirements-dev.txt
+      - run: sudo tools/setup_linux_compute_gate.sh
+      - env:
+          PAPERFORGE_REAL_DOCKER: "1"
+          PAPERFORGE_REAL_SSH: "1"
+          PAPERFORGE_REAL_SLURM: "1"
+          PAPERFORGE_SLURM_IMAGE: /tmp/paperforge-python.sif
+          PAPERFORGE_REAL_KUBERNETES: "1"
+          PAPERFORGE_KUBECTL: /usr/local/bin/kubectl
+          PAPERFORGE_KUBERNETES_CONTEXT: kind-paperforge-v3
+          PAPERFORGE_KUBERNETES_NAMESPACE: paperforge-v3
+        run: python -m pytest -q tests/integration/test_real_compute_backends.py
+      - if: always()
+        run: |
+          kind delete cluster --name paperforge-v3 || true
+          sudo rm -f /tmp/paperforge-python.sif

docs/V3_VALIDATION_CHECKPOINT.md

@@ -4,72 +4,102 @@ Date: 2026-07-25
 
 ## Release decision
 
-Status: `RELEASE_BLOCKED`
+Status: `RELEASE_CANDIDATE`
 
-The v3 source is code-complete and the available local end-to-end gates pass, but
-the official `v3.0.0` release is intentionally withheld. The approved release
-plan requires a real Windows VM run, and no Windows runtime is available on this
-host. Consequently there is no `v3.0.0` Git tag, official source ZIP, MambaIR
-workspace ZIP, or final delivery report.
+The v3 source is code-complete and the macOS, Linux, real-compute, publication,
+security, and review gates pass. On 2026-07-26 the release scope was explicitly
+changed to defer Windows validation, so the missing Windows runtime no longer
+blocks the current macOS/Linux release. The source ZIP, MambaIR workspace ZIP,
+delivery report, and `v3.0.0` tag are produced only by the final release step.
 
 ## Verified results
 
 - `CODE_VERIFIED`
   - macOS 15.7.2 arm64
-  - Python 3.10.20: 252 tests passed
-  - Python 3.11.15: 252 tests passed
-  - Python 3.12.13: 252 tests passed
-  - Linux x86_64 Python 3.11: 250 non-Git tests passed with the exact
-    writing dependency set under QEMU; the two real Git tests passed in the
-    native Linux arm64 VM
-  - Linux arm64 Python 3.12 clean wheel install: 110 core, security, backend,
-    publication, and real Git tests passed
+  - Final macOS full suite: 333 passed, 5 real-compute gates skipped
+  - Python 3.10.20, 3.11.15, and 3.12.13 passed clean full-suite validation;
+    the final Docker/GitHub delta passed 12 tests on each version
+  - Linux arm64 Python 3.12.3 full suite: 325 passed, 6 platform/runtime gates
+    skipped; the final delta passed 11 tests with one case-insensitive-filesystem
+    test skipped
   - Ruff passed
-  - Mypy passed for 55 PaperForge source files
+  - Mypy passed for 64 PaperForge source files
   - Node syntax check passed for `frontend/app.js`
-  - Wheel and sdist built; clean wheel installation, dependency check,
+  - Wheel built; clean wheel installation, dependency check,
     preflight, console entry point, metadata, launchers, templates, few-shot
     examples, rubrics, and packaged assets passed
-  - Final wheel SHA-256:
-    `3aadce7756b81bcc6fdcad50639589fd957063d8a88900d0f6dc414f51c3e63c`
-  - Final sdist SHA-256:
-    `5c82f525f269964b04675e71c6069da36489f97ff97dac0bd2e980e88113ee4a`
-  - Source secret scan passed: 221 files scanned, zero findings
-  - Independent final code and Python reviews found no Critical, High, or
-    Medium findings
+  - Current verified wheel SHA-256:
+    `667c5c7cd212590c55fdfcff6ecef2d17578e1622e2f96ffc247a566af931f11`
+  - Source and reachable Git history secret scan passed: 262 worktree files
+    and 257 Git blobs scanned, zero findings
+  - Initial independent review blockers were fixed; final consolidated review
+    verdict: `APPROVE`, with zero critical, high, medium, or low findings
 
 - `LOCAL_E2E_VERIFIED`
   - Local, Docker, OpenSSH, Cloud-SSH, Slurm 23.11.4, and Kind/Kubernetes
     backends exercised against real local runtimes
   - Submit, status, logs, artifact synchronization, cancellation, and resume
     paths exercised
   - Frontend loaded through Playwright with no browser console errors
-  - Generic, CVPR, IEEE, and Elsevier publication profiles compiled and rendered
-  - MambaIR-GPPNN writing-only candidate: 94/94 claims mapped, five PDF pages
-    rendered and inspected, protected hashes unchanged, and release manifest
-    verified
+  - Generic, CVPR, IEEE, and Elsevier publication profiles compiled, rendered,
+    and passed authoritative release revalidation in both empty-Bib and
+    existing-Bib states (eight combinations)
+  - CVPR author-kit was validated at locked commit
+    `291758547e923160eb4d37079b7b9f0dfce82355`, tree
+    `bada7af3a66da84fd610948fd72ce5dd01fb3cc2`, and git-archive SHA-256
+    `72df21fe120ab08c59980bc9461c6cafc427149e6400684749e731086efce5d6`;
+    the kit is not redistributed
+  - Release verification now extracts the locked source bundle into a system
+    temporary directory, requires byte-identical internal/external source
+    locks, recompiles, rerenders, recomputes Claim/source invariants, and
+    requires rebuilt page hashes to match both the official PDF render and the
+    inspected page hashes
+  - Every validation render passed decoded-pixel blank-page, saturation, and
+    border-cropping checks in addition to TeX layout diagnostics
+  - MambaIR-GPPNN writing-only candidate: 93/93 public claims mapped, five PDF
+    pages freshly rebuilt, rendered, and inspected; protected hashes, source
+    locks, bundle checksums, official page hashes, and release manifest passed
   - MambaIR-GPPNN source pinned to commit
     `5e24e22c0f726fa73fa924afb1d1d186ca677b7b`
+  - MambaIR-GPPNN source tree SHA-256:
+    `6129f9393b89bfc91bd29acd978fedae9dd3c987128ff3b9ae802b9fb4c61181`
 
 - `EXTERNAL_SERVICE_AUTH_BLOCKED`
   - The one permitted Bailu preflight returned HTTP 401.
   - The runtime entered `AUTH_BLOCKED`; no long-generation retry was issued.
 
 - Original repository protection
-  - `/Users/qjhwc/Desktop/PaperForge/` pre/post archive SHA-256:
+  - `/Users/qjhwc/Desktop/PaperForge/` pre-upgrade archive SHA-256:
     `16524ab87999a1b442d37cda4dfd047fa0f33e3e63a55fdad2b49e64e3762634`
-  - The original directory remained unchanged.
+  - All 7,681 files captured by the pre-upgrade content manifest still match
+    their SHA-256 values; zero files have modification times after the
+    baseline.
+  - A prior read-only Git validation changed only the nested `.git` directory
+    mtime, so a byte-identical tar stream cannot be claimed. No original file
+    content was modified.
 
-## Open release gate
+## Deferred Windows validation
 
-`Windows fresh-install and E2E`: not executed. QEMU, VirtualBox, Parallels,
+`Windows fresh-install and E2E` has not been executed. QEMU, VirtualBox, Parallels,
 UTM, Wine, and Windows PowerShell are unavailable on this host.
 
 The Windows ACL implementation is fail-closed and has platform-independent
 payload tests for trusted owners, untrusted readers/writers, missing DACLs, and
 NULL DACLs. These tests do not replace the required execution on real Windows.
 
-This is a verification-environment blocker, not permission to downgrade the
-gate. Official release artifacts must remain absent until the Windows run
-passes. GitHub publication also remains local-only because no explicit remote
-and approval were provided.
+Run the complete gate from an elevated or standard PowerShell session with
+Python 3.10-3.12, Git, Node, TeX Live/MiKTeX, and Poppler already available:
+
+```powershell
+powershell -ExecutionPolicy Bypass -File tools/run_windows_gate.ps1 `
+  -OutputFile "$env:TEMP\paperforge-windows-gate.json"
+```
+
+The script builds one wheel, installs that wheel into fresh Python 3.10, 3.11,
+and 3.12 environments, runs isolated import and dependency checks, then runs
+the full test suite, Ruff, Mypy, Node syntax validation, the pinned CVPR lock,
+and all eight publication profile/Bib combinations. It fails unless the host
+is real Windows.
+
+This remains the required gate before claiming Windows support. It is not part
+of the current macOS/Linux release scope and must not be reported as passed.

engine/secret_redaction.py

@@ -276,3 +276,31 @@ def redact_structure(
     if isinstance(value, os.PathLike):
         return redact_secrets(os.fspath(value), secret_values=values)
     return value
+
+
+def contains_secret(value: Any) -> bool:
+    """Return True when a JSON-like value would require secret redaction."""
+
+    if isinstance(value, Mapping):
+        for key, item in value.items():
+            if _is_secret_field(key) and item not in (None, ""):
+                return True
+            normalized_key = _normalize_field_name(key)
+            if normalized_key in {"command", "argv", "args"} and isinstance(
+                item, str | Sequence
+            ):
+                original = [item] if isinstance(item, str) else [str(part) for part in item]
+                if redact_command(item) != original:
+                    return True
+            if contains_secret(item):
+                return True
+        return False
+    if isinstance(value, list | tuple | set | frozenset):
+        return any(contains_secret(item) for item in value)
+    if isinstance(value, bytes):
+        rendered = value.decode("utf-8", errors="replace")
+        return redact_secrets(rendered) != rendered
+    if isinstance(value, str | os.PathLike):
+        rendered = os.fspath(value)
+        return redact_secrets(rendered) != rendered
+    return False

paperforge/agents.py

@@ -10,6 +10,8 @@
 from pathlib import Path
 from typing import Any, Protocol, cast, runtime_checkable
 
+from engine.secret_redaction import redact_structure
+
 from .artifacts import ArtifactStore, sha256_file
 from .models import utc_now
 
@@ -49,6 +51,7 @@ class AgentResultStatus(str, Enum):
     ACCEPTED = "ACCEPTED"
     COMPLETED = "COMPLETED"
     SUCCESS = "COMPLETED"
+    SKIPPED = "SKIPPED"
     BLOCKED = "BLOCKED"
     FAILED = "FAILED"
 
@@ -161,12 +164,14 @@ def persist(
         normalized_name = self._normalize_name(name)
         created_at = utc_now()
         trace_id = f"trace_{uuid.uuid4().hex}"
+        safe_payload = redact_structure(payload)
+        safe_metadata = redact_structure(dict(metadata or {}))
         envelope: dict[str, Any] = {
             "schema_version": TRACE_SCHEMA_VERSION,
             "trace_id": trace_id,
             "created_at": created_at,
-            "payload": payload,
-            "metadata": dict(metadata or {}),
+            "payload": safe_payload,
+            "metadata": safe_metadata,
         }
         canonical = json.dumps(
             envelope,
@@ -180,15 +185,15 @@ def persist(
             relative_path,
             envelope,
             kind="trace",
-            metadata=metadata,
+            metadata=safe_metadata,
         )
         return TraceInput(
             trace_id=trace_id,
             path=record.path,
             sha256=record.sha256,
             size_bytes=record.size_bytes,
             created_at=created_at,
-            metadata=dict(metadata or {}),
+            metadata=safe_metadata,
         )
 
     def verify(self, trace: TraceInput) -> bool:
@@ -345,6 +350,19 @@ def completed(
             trace_outputs=tuple(trace_outputs),
         )
 
+    @classmethod
+    def skipped(
+        cls,
+        request: AgentRequest,
+        output: Mapping[str, Any] | None = None,
+    ) -> AgentResult:
+        return cls(
+            request_id=request.request_id,
+            role=request.role,
+            status=AgentResultStatus.SKIPPED,
+            output=dict(output or {}),
+        )
+
     @classmethod
     def failed(cls, request: AgentRequest, error: str) -> AgentResult:
         return cls(