Establish dependency returns and block gated workplans

Assistant: codex
Assistant-Model: gpt-6.1-sol
Assistant-Session: 01a1045b-933d-7aa1-b2db-104557487a79

Makefile

@@ -41,9 +41,12 @@ reference-test:
 consumption-test:
 	PYTHONDONTWRITEBYTECODE=1 "$(BENCH_PY)" -m pytest -q -p no:cacheprovider tests/test_reference_consume.py
 
-.PHONY: replication-check replication-test
+.PHONY: replication-check replication-test inference-preflight
 replication-check:
 	python3 scripts/language_replication.py check
 
 replication-test:
-	PYTHONDONTWRITEBYTECODE=1 "$(BENCH_PY)" -m pytest -q -p no:cacheprovider tests/test_language_replication.py
+	PYTHONDONTWRITEBYTECODE=1 "$(BENCH_PY)" -m pytest -q -p no:cacheprovider tests/test_language_replication.py tests/test_inference_preflight.py
+
+inference-preflight:
+	python3 scripts/inference_preflight.py

SCOPE.md

@@ -88,8 +88,10 @@ owns architectural contrasts, broader walkthroughs and M2; [WP-0004](workplans/F
 owns gated canonical export, held-out retrieval and real-repository evaluation.
 [WP-0006](workplans/FEP-WP-0006-language-evolution.md) owns comparable learning evidence;
 [WP-0008](workplans/FEP-WP-0008-use-driven-improvement.md) owns discovery, eligible
-consumer integration/outcomes and end-to-end autonomous improvement. Workplan files
-are authoritative; this document is a capability inventory, not a duplicate backlog.
+consumer integration/outcomes and end-to-end autonomous improvement.
+[Dependency requirements](docs/DependencyRequirements.md) define the owner returns
+and evidence needed to unblock them. Workplan files are authoritative; this document
+is a capability inventory, not a duplicate backlog.
 
 The [current scope–intent assessment](history/2026-10-04T084941+0200-scope-vs-intent.md)
 prioritizes consumer decision/outcome evidence, independent validation and qualified

WORK-RECORDS.md

@@ -10,8 +10,8 @@
 | --- | --- | --- | --- | --- |
 | workplan | FEP-WP-0001 | finished | — | workplans/FEP-WP-0001-statehub-bootstrap.md |
 | workplan | FEP-WP-0002 | finished | — | workplans/FEP-WP-0002-seed-language-validation.md |
-| workplan | FEP-WP-0003 | backlog | — | workplans/FEP-WP-0003-contrasting-schools.md |
-| workplan | FEP-WP-0004 | backlog | — | workplans/FEP-WP-0004-reference-surface.md |
+| workplan | FEP-WP-0003 | blocked | — | workplans/FEP-WP-0003-contrasting-schools.md |
+| workplan | FEP-WP-0004 | blocked | — | workplans/FEP-WP-0004-reference-surface.md |
 | workplan | FEP-WP-0005 | finished | — | workplans/FEP-WP-0005-research-bench-setup.md |
 | workplan | FEP-WP-0006 | blocked | — | workplans/FEP-WP-0006-language-evolution.md |
 | workplan | FEP-WP-0007 | finished | — | workplans/FEP-WP-0007-language-v01-preview.md |

docs/DependencyRequirements.md

@@ -0,0 +1,57 @@
+# Requirements to unblock frontend-patterns work
+
+Reviewed 2026-10-04 against local owner files. This is a dependency acceptance
+contract attached to the existing FEP tasks, not an owner acceptance, runtime grant
+or claim that another repo has received a handoff. Workplan files remain authoritative.
+Tasks use `wait` for blocked work; plans use `blocked` when no currently available
+implementation can meet their remaining acceptance. No new source study is warranted
+solely to fill a comparison window. The paused navigation fixture stays paused.
+
+## Cross-repository requirements
+
+| Requirement | Blocked local task | Responsible surface / live record | Required return before moving forward |
+| --- | --- | --- | --- |
+| Hosted discovery | FEP-WP-0008-T01 | reuse-surface hosted federation; credential custody railiance-platform/OpenBao, route `reuse-surface-hub-write-token` | Authorized registration of `capability.infotech.frontend-pattern-language`; anonymous/consumer lookup returns the exact entry, stable raw index and pinned release citations. Retain registration/readback evidence and owner revision. A prepared YAML entry or 404 is insufficient. |
+| Actual consumer and common hook | FEP-WP-0008-T01/T02 | the-custodian/repo-seed common template owner plus the selected consumer repository owner; no eligible consumer identified in the bounded October 4 search | Name an actual eligible task and revision, install query/read/cite/record plus automatic closeout/index commit via normal template rollout, and retain a pinned decision note. Do not enroll a finished example, fixture or invented task. Return the concrete native consumer task ID when one exists; no dependency ID is fabricated meanwhile. |
+| Receipt collection and delayed outcomes | FEP-WP-0008-T02 | selected consumer producer; activity-core collector (ACTIVITY-WP-0040 is finished) | Authorized source enrollment with exact index/event digests; one real use plus linked inspectable outcome, explicit unknowns and producer assertions; automatic artifact refresh after 14 days and unknown after 30. Retain duplicate/collision/malformed and delayed-chain proofs. Local producer/helper and existing collector are implemented; their fixtures do not satisfy real use. Route an uncovered collector change to an owner live record before activation, rather than reopening finished work by implication. |
+| Admitted execution and budget | FEP-WP-0008-T03 | glas-harness GLAS-WP-0012-T02–T05; prj-helixforge-factory HFACT-WP-0001; activity-core ACTIVITY-WP-0032-T05 | Owner returns pinned admitted profile/runtime, scoped read/write/test/commit/publication grants, protected provider route and enforcement of six calls / 40,000 aggregate tokens / 30 minutes before execution. Include duplicate dispatch, restart, denial, provider failure, separate review context and audit/usage receipts. The candidate profile `1.1.1` is unverified; no legacy fallback. GLAS-WP-0012 directly waits on SAND-WP-0014-T05 and SECRETS-WP-0009-T03. Existing source/synthetic proofs do not establish admission. |
+| Standing publication and rollback | FEP-WP-0008-T03 | activity-core ACTIVITY-WP-0041-T02/T03; railiance-platform RPF-WP-0048-T02 | Exact narrowly bound release identity and approved autonomous scope; authenticated CI/review/health issuers, full current continuous-health interval, production transport/observer integration and retained failed-health rollback proof. Publish/read back the exact reference revision; refuse denied mutation and preserve previous versions. Broker source tests and the attended September repair are insufficient. |
+| Reachable inference path | FEP-WP-0009-T02 | llm-connect service contract; ops-bridge owns a workstation tunnel when required; deployment stays with its platform owner | Supply a documented accessible service origin from this execution environment and an HTTP 200 `GET /health` with `status: ok`; record endpoint, timestamp and runtime/profile owner revision. Owner must also establish `custodian-triage-balanced` resolution, requested 1,400-output-token enforcement, aggregate authorized attempt ceiling and usable usage/error receipts. Health alone proves neither provider readiness nor caps. Historical finished LLM-WP-0006 establishes the internal service contract, not a pending restoration task or present workstation connectivity. A newly found routing/deployment defect needs a native owner live record before repair; FEP does not fabricate its ID. |
+
+### Return format and local verification
+
+For each return, retain the native owner task/workplan ID (or document that it is
+not yet assigned), source commit and artifact digest, exact tested environment,
+dated evidence locators, remaining limits and admission scope. FEP verifies the
+specific required behavior before clearing its wait; an upstream `done` label alone
+is insufficient. External source status may have changed since this review.
+
+No messages, external workplan edits, consumer enrollment, deployment or secret
+retrieval are implied by filing this contract. Credential requests first use
+`warden route find/show`; keys never enter this repo, chat or State Hub. The user
+can review these concrete requirements without approving a speculative workflow.
+
+## Local evidence gates and remaining implementation
+
+| Local task(s) | Required evidence / what can be done now |
+| --- | --- |
+| WP-0009 T01 | Actual independent human review of the existing masked pilot-01 worksheet, disagreements and adjudication. Model scores cannot supply it. Human review instructions and blank sheet are already prepared. |
+| WP-0009 T02 | Packet/runner/scoring are implemented; all twelve authorized attempts are reserved and failed, with no answers. The health-only preflight is now implemented separately, preserving frozen bytes. Service restoration and a fresh explicit budget/new preregistered run identity are required; do not retry or reuse the old identities. |
+| WP-0009 T03 | Independent ratings plus usable fresh replication, then evidence-based M1 pass/revise/defer. Remains wait. |
+| WP-0003 T01/T02 | M1 evidence gate WP-0009 T03, then full six-stream comparison and contrasting walkthroughs. Bounded source/runtime preparation already exists; no useful consumer-led new question was identified. Full-contract/AT/human evidence cannot be invented. T03 editorial M2 review and T04 concrete recovery experiment remain done with limits. |
+| WP-0004 T01 | M1 acceptance, then canonical validator/exporter. Existing preview validators/export do not confer canonical admission. |
+| WP-0004 T02 | Canonical export WP-0004 T01 **and an accepted M2 assessment** after WP-0003 T01/T02; completed editorial WP-0003 T03 currently says revise/defer. Then freeze at least six unseen prompts and compare manual navigation, alternatives, abstentions and unsupported claims. Previously disclosed cases are consumed. |
+| WP-0004 T03 | Completed held-out evaluation, then two contrasting pinned real repositories and M3 empirical review. No studies are fabricated to clear it. |
+| WP-0006 T03 | Useful naturally arising comparable prospective cycles and explicit protocol/returns review from WP-0003 or consumer-led WP-0008. Largest group has two cycles, one with unknown effort. LEARN-0019 has no answers and is a separate failed protocol; it cannot be pooled to meet the trigger. |
+| WP-0008 T03 | After the owner returns and actual consumer outcomes above: a real unassisted scheduled end-to-end cycle, natural monthly packet, retained failure/restart/rollback tests and exact publication readback. Natural reporting is verified; automatic editing is still unadmitted. |
+
+## Health-only preflight implemented under WP-0009 T02
+
+Run `make inference-preflight` or
+`python3 scripts/inference_preflight.py --endpoint http://127.0.0.1:18081`.
+The command sends exactly one bounded GET to `/health`, follows no redirects,
+prints only sanitized status, performs no `/execute`, reserves no attempt and
+exits nonzero for unreachable/invalid health. A sandbox loopback failure must be
+checked outside the sandbox before declaring the service unavailable. This is a
+preparation aid for a future newly authorized packet, not a change to replication-02's
+frozen runner or a way to regain its spent reservations.

docs/evidence/2026-10-04-blocked-task-review.json

@@ -0,0 +1,39 @@
+{
+  "schema_version": 1,
+  "reviewed_at": "2026-10-04T09:29:51.976345+00:00",
+  "local_source": "5da8b2405cff6bac2392dd83d241d3d64b9de409",
+  "owner_source_revisions": {
+    "activity-core": "3dd68d118b3fb60e45926dcb238d4f1ab4d447ac",
+    "glas-harness": "5ce4f38aedfd27cc783131f18480df02e2951514",
+    "prj-helixforge-factory": "328ce7a141d1eebebd25727f1e78189f466d0295",
+    "llm-connect": "9dc6b39766cea2b9904d80c40bee0df89d444c8f"
+  },
+  "health_probe": {
+    "endpoint": "http://127.0.0.1:18081",
+    "sandbox": {
+      "exit_code": 1,
+      "reason": "health_unreachable"
+    },
+    "host": {
+      "exit_code": 1,
+      "reason": "health_unreachable"
+    },
+    "inference_calls": 0,
+    "attempts_reserved": 0
+  },
+  "workplans_blocked": [
+    "FEP-WP-0003",
+    "FEP-WP-0004",
+    "FEP-WP-0006",
+    "FEP-WP-0008",
+    "FEP-WP-0009"
+  ],
+  "unfinished_tasks_wait": 12,
+  "requirements_ref": "docs/DependencyRequirements.md",
+  "limits": [
+    "Owner revisions are local checkout snapshots, not live runtime attestations.",
+    "Historical LLM-WP-0006 is finished and supplies a contract, not an open restoration task.",
+    "Unidentified consumer and unassigned endpoint-restoration owner tasks are explicitly unresolved; no owner record ID fabricated.",
+    "No external messages, repository writes, deployments, credentials, enrollments or inference attempts performed."
+  ]
+}

history/2026-10-04T112951+0200-blocked-task-review.md

@@ -0,0 +1,34 @@
+# Blocked-task review — 2026-10-04
+
+Reviewed all twelve unfinished tasks across WP-0003/0004/0006/0008/0009. Existing
+local preparation is implemented; remaining acceptance depends on real consumer
+use/outcomes, independent human evidence, qualified gates or admitted external
+execution/publication. No task was falsely closed and no paid call was made.
+WP-0003 and WP-0004 changed from backlog to blocked; all five unfinished plans are
+blocked and remaining tasks use wait, the repository's blocked task status.
+
+[Dependency contract](../docs/DependencyRequirements.md) establishes specific owner
+returns for hosted discovery, common-template/consumer integration, enrollment and
+delayed outcomes, admitted execution/budget, standing publication/rollback and a
+reachable inference route. Requirements attach to existing local tasks; unidentified
+consumer/restoration owner records remain explicit instead of invented. Existing
+Glas/factory/activity-core live records are named; finished LLM-WP-0006 is only a
+historical service contract. No external handoff message or owner-file edit is claimed.
+
+Corrected WP-0008 T02's stale receipt-contract blocker: local producer/collector
+are available, but actual closeout integration/enrollment/linked outcomes are missing.
+WP-0008 T03 now names its factory and scheduler admission chain. Corrected WP-0004
+T02: held-out evaluation needs canonical export AND accepted M2 evidence following
+WP-0003 T01/T02; editorial review currently says revise/defer.
+
+Implemented a separate health-only preflight under WP-0009 T02 to detect endpoint
+failure before future authorized attempt reservation. It sends one bounded GET,
+follows no redirects, emits no response/error body, never executes a prompt and
+exits nonzero on failure. Frozen replication-02 bytes remain unchanged. Host and
+sandbox checks both found the endpoint unreachable, with zero calls/reservations.
+A future new packet still requires owner-confirmed profile/caps and fresh budget;
+health alone does not authorize or prove inference readiness.
+
+Verification: 30 replication/preflight tests passed. Immutable replication, evolution,
+classification and reference checks passed; whitespace passed. Retained source
+revisions and probe results: [review evidence](../docs/evidence/2026-10-04-blocked-task-review.json).

scripts/inference_preflight.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Health-only check before a future authorized run; never reserves or executes calls."""
+import argparse
+import json
+from urllib import error, request
+from urllib.parse import urlsplit
+
+
+class NoRedirect(request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+def probe(endpoint, timeout=5, opener=None):
+    parsed = urlsplit(endpoint)
+    if (parsed.scheme not in {'http', 'https'} or not parsed.hostname
+            or parsed.username or parsed.password or parsed.query or parsed.fragment
+            or parsed.path not in {'', '/'}):
+        raise ValueError('Use an HTTP(S) service origin without credentials, path or query')
+    if not 0 < timeout <= 15:
+        raise ValueError('Health timeout must be greater than zero and at most 15 seconds')
+    opener = opener or request.build_opener(NoRedirect())
+    result = {'endpoint': endpoint.rstrip('/'), 'ready': False,
+              'inference_calls': 0, 'attempts_reserved': 0,
+              'limit': 'Health only; profile, provider, token enforcement and authorization are unverified.'}
+    try:
+        req = request.Request(endpoint.rstrip('/') + '/health', method='GET')
+        with opener.open(req, timeout=timeout) as response:
+            body = response.read(4097)
+            if response.status != 200 or len(body) > 4096:
+                result['reason'] = 'invalid_health_response'
+            else:
+                data = json.loads(body)
+                result['ready'] = isinstance(data, dict) and data.get('status') == 'ok'
+                result['reason'] = 'health_ok' if result['ready'] else 'invalid_health_response'
+    except error.HTTPError as exc:
+        result.update(reason='health_http_error', http_status=exc.code)
+    except (error.URLError, TimeoutError, OSError):
+        result['reason'] = 'health_unreachable'
+    except (ValueError, UnicodeError):
+        result['reason'] = 'invalid_health_response'
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--endpoint', default='http://127.0.0.1:18081')
+    parser.add_argument('--timeout', type=float, default=5)
+    args = parser.parse_args()
+    try:
+        result = probe(args.endpoint, args.timeout)
+    except ValueError as exc:
+        parser.error(str(exc))
+    print(json.dumps(result, indent=2))
+    return 0 if result['ready'] else 1
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

tests/test_inference_preflight.py

@@ -0,0 +1,67 @@
+"""No provider calls or response-body disclosure in readiness checks."""
+import io
+import json
+import sys
+from pathlib import Path
+from urllib import error
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts'))
+from inference_preflight import NoRedirect, probe
+
+
+class Response(io.BytesIO):
+    status = 200
+
+
+class Opener:
+    def __init__(self, body=b'{"status":"ok"}', exception=None):
+        self.body, self.exception, self.requests = body, exception, []
+
+    def open(self, req, timeout):
+        self.requests.append((req, timeout))
+        if self.exception:
+            raise self.exception
+        return Response(self.body)
+
+
+def test_success_is_one_get_with_no_prompt_or_reservation():
+    opener = Opener()
+    result = probe('http://127.0.0.1:18081', opener=opener)
+    req, timeout = opener.requests[0]
+    assert req.full_url == 'http://127.0.0.1:18081/health'
+    assert req.get_method() == 'GET' and req.data is None
+    assert len(opener.requests) == 1 and timeout == 5
+    assert result['ready'] and result['inference_calls'] == result['attempts_reserved'] == 0
+
+
+@pytest.mark.parametrize('body', [b'sensitive-invalid-body', b'{"status":"bad","secret":"sentinel"}', b'[]', b'x' * 4097])
+def test_malformed_body_blocks_without_echo(body):
+    result = probe('http://localhost:8080', opener=Opener(body))
+    assert not result['ready'] and result['reason'] == 'invalid_health_response'
+    assert 'sentinel' not in json.dumps(result) and 'sensitive' not in json.dumps(result)
+
+
+@pytest.mark.parametrize('exception,reason', [
+    (error.URLError('sensitive transport detail'), 'health_unreachable'),
+    (TimeoutError('sensitive timeout detail'), 'health_unreachable'),
+    (error.HTTPError('http://localhost', 503, 'sensitive error', {}, None), 'health_http_error'),
+])
+def test_failure_has_no_retry_and_no_error_detail(exception, reason):
+    opener = Opener(exception=exception)
+    result = probe('http://localhost:8080', opener=opener)
+    assert not result['ready'] and result['reason'] == reason
+    assert len(opener.requests) == 1 and 'sensitive' not in json.dumps(result)
+
+
+@pytest.mark.parametrize('endpoint', ['file:///tmp/x', 'http://user:password@localhost', 'http://localhost/execute', 'http://localhost?token=x', 'http://localhost#x'])
+def test_invalid_origin_never_requests(endpoint):
+    opener = Opener()
+    with pytest.raises(ValueError):
+        probe(endpoint, opener=opener)
+    assert not opener.requests
+
+
+def test_redirect_is_not_followed():
+    assert NoRedirect().redirect_request(None, None, 302, '', {}, 'http://elsewhere') is None

workplans/FEP-WP-0003-contrasting-schools.md

@@ -4,11 +4,11 @@ type: workplan
 title: "Challenge the language across architectural schools"
 domain: infotech
 repo: frontend-patterns
-status: backlog
+status: blocked
 owner: codex
 topic_slug: canon
 created: "2026-09-24"
-updated: "2026-10-03"
+updated: "2026-10-04"
 state_hub_workstream_id: "13c123f1-a470-560e-ab8e-b270c387930a"
 ---
 
@@ -406,3 +406,13 @@ composition responsibility, portability benefit and implementation/compatibility
 costs; added the mapping and regenerated the report. Runtime-carrier choice is not
 itself an execution-responsibility claim. Eighteen hypotheses now classify without
 changing candidate content or the frozen seventeen-record preview.
+
+
+## Blocked-task review — 2026-10-04
+
+[Dependency requirements](../docs/DependencyRequirements.md) establish exact owner
+returns and local evidence gates for every remaining task. All unfinished tasks
+stay `wait`; this plan is `blocked` because no currently available implementation
+can meet its remaining acceptance. Completed deliverables remain done with their
+recorded limits. Cross-repo source/synthetic proofs and finished editorial reviews
+are not the missing runtime admission, actual consumer or human evidence.

workplans/FEP-WP-0004-reference-surface.md

@@ -4,11 +4,11 @@ type: workplan
 title: "Evaluate retrieval and real repository applicability"
 domain: infotech
 repo: frontend-patterns
-status: backlog
+status: blocked
 owner: codex
 topic_slug: canon
 created: "2026-09-24"
-updated: "2026-10-03"
+updated: "2026-10-04"
 state_hub_workstream_id: "831bbc30-30c0-5df3-a315-5355cd3b8ee5"
 ---
 
@@ -36,8 +36,8 @@ After the schema and seed examples pass M1, implement the smallest validator/exp
 ```task
 id: FEP-WP-0004-T02
 status: wait
-depends_on: [FEP-WP-0004-T01]
-blocking_reason: "After M2 (FEP-WP-0004-T01)."
+depends_on: [FEP-WP-0004-T01, FEP-WP-0003-T01, FEP-WP-0003-T02]
+blocking_reason: "Needs canonical export (FEP-WP-0004-T01) and an accepted M2 reassessment following FEP-WP-0003-T01/T02; completed editorial review currently says revise/defer."
 priority: medium
 state_hub_task_id: "4bdd4c53-fcdb-5dfd-9a37-ebc3fee4d445"
 ```
@@ -73,3 +73,13 @@ M2 under the phase prerequisite. The M1 and M2 reviews both say revise/defer. Re
 each task only on the recorded prerequisite evidence. Existing preview validation
 and development cases are useful outputs of WP-0007/WP-0008, not canonical export,
 held-out evaluation or two complete real-repository applicability studies.
+
+
+## Blocked-task review — 2026-10-04
+
+[Dependency requirements](../docs/DependencyRequirements.md) establish exact owner
+returns and local evidence gates for every remaining task. All unfinished tasks
+stay `wait`; this plan is `blocked` because no currently available implementation
+can meet its remaining acceptance. Completed deliverables remain done with their
+recorded limits. Cross-repo source/synthetic proofs and finished editorial reviews
+are not the missing runtime admission, actual consumer or human evidence.

workplans/FEP-WP-0006-language-evolution.md

@@ -264,3 +264,13 @@ measured. The ledger now has nine prospective attempts/cycles in eight groups,
 including this wholly failed run. Largest group remains two, with LEARN-0017 effort
 unknown. This failure is retained and cannot establish returns or close T03's
 three-cycle prerequisite. WP-0009 T02 owns restoration/future authorized replication.
+
+
+## Blocked-task review — 2026-10-04
+
+[Dependency requirements](../docs/DependencyRequirements.md) establish exact owner
+returns and local evidence gates for every remaining task. All unfinished tasks
+stay `wait`; this plan is `blocked` because no currently available implementation
+can meet its remaining acceptance. Completed deliverables remain done with their
+recorded limits. Cross-repo source/synthetic proofs and finished editorial reviews
+are not the missing runtime admission, actual consumer or human evidence.

workplans/FEP-WP-0008-use-driven-improvement.md

@@ -71,7 +71,7 @@ first pinned decision note. No fixture or audit of this repo supplies that recei
 id: FEP-WP-0008-T02
 status: wait
 depends_on: [FEP-WP-0008-T01]
-blocking_reason: "Receipt contract follows the published capability entry (T01)."
+blocking_reason: "Local producer and collector contracts are implemented; needs an actual consumer-owned automatic closeout/index hook, authorized enrollment, real use plus linked outcome and delayed-artifact refresh. See docs/DependencyRequirements.md."
 priority: high
 lane: blue
 state_hub_task_id: "49be8a8e-eaaf-5f1c-b4cd-f0c4dbac9823"
@@ -107,7 +107,7 @@ collection remains with activity-core; no second collector or fictional use was
 ```task
 id: FEP-WP-0008-T03
 status: wait
-depends_on: [FEP-WP-0008-T02, GLAS-WP-0012, ACTIVITY-WP-0041-T03]
+depends_on: [FEP-WP-0008-T02, GLAS-WP-0012, HFACT-WP-0001, ACTIVITY-WP-0032-T05, ACTIVITY-WP-0041-T03]
 blocking_reason: "Reporting cadence is verified. Needs real consumer outcomes, admitted budget-enforced improvement execution and authenticated publication/rollback proof."
 priority: high
 lane: blue
@@ -324,3 +324,13 @@ No external task was reopened or invented, and no synthetic event was enrolled.
 T01/T02 retain actual source-verified task selection and common-template integration.
 WP-0009's authorized fresh replication advances independent-validation preparation;
 it does not replace the consumer decision/outcome acceptance in this plan.
+
+
+## Blocked-task review — 2026-10-04
+
+[Dependency requirements](../docs/DependencyRequirements.md) establish exact owner
+returns and local evidence gates for every remaining task. All unfinished tasks
+stay `wait`; this plan is `blocked` because no currently available implementation
+can meet its remaining acceptance. Completed deliverables remain done with their
+recorded limits. Cross-repo source/synthetic proofs and finished editorial reviews
+are not the missing runtime admission, actual consumer or human evidence.

workplans/FEP-WP-0009-m1-independent-validation.md

@@ -111,3 +111,19 @@ comparison exists. Future execution needs a new registered packet/run identity a
 fresh explicit authorization after service restoration. T01 and T03 retain their
 existing gates. LEARN-0019 records one inconclusive attempted cycle, not useful
 validation or independent evidence.
+
+
+## Blocked-task review — 2026-10-04
+
+[Dependency requirements](../docs/DependencyRequirements.md) establish exact owner
+returns and local evidence gates for every remaining task. All unfinished tasks
+stay `wait`; this plan is `blocked` because no currently available implementation
+can meet its remaining acceptance. Completed deliverables remain done with their
+recorded limits. Cross-repo source/synthetic proofs and finished editorial reviews
+are not the missing runtime admission, actual consumer or human evidence.
+
+
+Implemented `scripts/inference_preflight.py` under T02: one bounded sanitized
+health-only GET, no redirects, provider execution, reservations or retries. Frozen
+replication-02 inputs/runner are unchanged. A reachable service, owner-confirmed
+profile/cap behavior and fresh explicitly authorized packet remain required.