attempts: 사다리 1단 캠페인을 열고 첫 측정이 경로 하나를 죽임

in-tab TLS는 천장 사다리의 첫 단이고, 모든 후속 단이 그 신뢰 모델을 상속하기 때문에 먼저다.
지금 릴레이는 https에서 TLS를 종단하므로 평문을 본다: 그래서 "신뢰하는 릴레이"가 요구사항이고,
탭 안에서 종단하면 그것이 "아무 릴레이나"로 내려간다.

첫 probe가 릴레이 코드 한 줄 전에 답을 냈다. Pyodide의 ssl은 있지만 OpenSSL이 stub이고
create_default_context().get_ca_certs()가 비어 있다. wrap_socket과 CERT_REQUIRED 기본값은
살아 있어서 표면이 그럴듯해 보이는데, 그것이 정확히 함정이다: 순진한 시도가 핸드셰이크까지
가서야 실패하거나 - 더 나쁘게 CERT_NONE으로 "고치면" - 검증 없는 TLS를 성공이라 보고한다.
졸업 게이트 2번이 그 모양을 잡으려고 있다.

남은 질문은 경로 2(WebCrypto 레코드 층)뿐이고, 원래 프레이밍이 놓친 요구가 하나 붙었다:
신뢰 루트를 어디서 가져오는가. 브라우저는 자기 루트 저장소를 페이지 스크립트에 빌려주지
않으므로 자산으로 실은 루트 번들(assetCatalog 규율이 이미 그 모양을 덮는다)이나 소비자별
핀이 후보다. 다음 probe는 레코드 층 코드를 쓰기 전에 그 비용부터 잰다.

검증: npm test 3728 passed 0 failed(attempts 구조 게이트가 README와 졸업 게이트 절을 검사한다).
probe 실행 결과 2/3이고 세 번째가 RED인 것이 이 캠페인의 첫 발견이다.

Author: eddmpython

mainPlan/stability-convergence/03-progress-ledger.md

@@ -247,8 +247,32 @@
   20개짜리 함수이거나 밖에서 객체를 변이시키는 형태가 되고, 둘 다 지금보다 나쁘다. 축이 하나면
   파일이 길어도 그것이 축이다(개발 원칙 3: 강함은 깎아서 나온다, 쪼개서 나오는 것이 아니다).
 
+## 2026-08-01 (7): 북극성 밀기와 사다리 1단 개설
+
+이번 흐름의 점수 이동은 전부 게이트를 먼저 세우고 그 뒤에 숫자를 옮긴 것이다(98.5 -> 103.5).
+
+- **원장이 실물보다 낮았다(+1.5).** 앞 커밋들이 next에서 항목을 지우고 evidence를 늘리면서
+  점수를 두고 갔다. 감사가 그 불일치를 잡았고 세 축을 실물에 맞췄다.
+- **소켓 밀폐 CI 레인(+0.5).** 릴레이가 저장소 안에 의존성 0으로 있었으므로 러너가 릴레이와
+  로컬 오리진을 소유하면 바깥으로 나가지 않는 레인이 된다. 네트워크 축의 수동 probe가 0이 됐다.
+- **정확히 한 번의 수렴 완성(+1.0).** 리더가 결과를 힙과 같은 세대에 기록하고, 끊긴 호출자는
+  대기했다 승계자에게 한 번 다시 묻는다. 순서도 보존된다. 소비자 게이트가 두 번 구멍을 잡았다
+  (부활 커널의 프록시 트랩, 세션 없는 follower가 리더의 힙을 모르면서 park한 것).
+- **x86 레인 CI 승격(+0.5).** "자산이 gitignore라 CI에서 못 돈다"가 낡은 문장이었다: 같은
+  워크플로가 같은 자산을 매 push마다 받는다. 감사가 예고한 함정(레인이 CI에 들어오는 순간
+  false-green이 될 음성 fixture)도 같은 커밋에서 막았다.
+- **구 봉투 일몰(+1.0).** 읽기만 남은 포맷은 계약이 아니라 부채였다. 브레이킹은 CHANGELOG에
+  쌓는다: 게시는 별개 결정이고 그 결정 없이도 main은 브레이킹을 안고 간다.
+- **측정으로 기각한 것**: SwiftShader GPU 어댑터(requestAdapter가 null을 준다).
+- **상한을 확정했다.** 12축 전수 대조 결과 120은 저장소 안에서 도달 불가다(정직한 상한 113.5,
+  릴리즈 승인 없이는 110.5). 6.5점이 upstream/브라우저 플랫폼에 있다: nogil, WASI 동적 링킹,
+  pyemscripten wheel, Direct Sockets 인바운드, WASM 스택 직렬화, upstream 재현 빌드.
+
+사다리 1단(in-tab TLS) 캠페인을 개설했고 첫 probe가 경로 하나를 즉시 죽였다: Pyodide의 ssl은
+OpenSSL stub이고 신뢰 루트가 0이다. 릴레이 코드를 쓰기 전에 알아낸 것이 그 순서의 값이다.
+
 ## NEXT
 
-이 이니셔티브의 목록은 비었다. 다음 작업은 새 이니셔티브 개설부터다(mainPlan/README.md 절차).
+이 이니셔티브의 목록은 비었다(북극성 밀기는 축의 next와 계약 실태 표가 들고 간다). 다음 작업은 새 이니셔티브 개설부터다(mainPlan/README.md 절차).
 남은 부채는 목록이 아니라 [계약 실태 표](../../docs/operations/contractReality.md)와 북극성 축의
 `next`가 들고 있다: 그 둘이 "무엇이 아직 참이 아닌가"의 정본이다.

tests/attempts/inTabTls/README.md

@@ -0,0 +1,82 @@
+# inTabTls - terminate TLS inside the tab
+
+One campaign, one question.
+
+## Question
+
+**Can a tab terminate TLS itself, so the WS-to-TCP relay carries ciphertext it cannot read?**
+
+Today `pyproc/socket` reaches the network through a relay that dials the real TCP endpoint. For
+`https://` the relay terminates TLS (`src/capabilities/socketBridge.js` bootstrap: `ssl.wrap_socket`
+is a pass-through because the relay already did the crypto). That is honest and documented, and it
+has one consequence that shapes everything above it: **the relay must be trusted.** It sees plaintext.
+
+That requirement is what rung 1 of the ceiling ladder exists to remove
+([product direction](../../../docs/product/vision.md#where-the-ceiling-moves-next)). If TLS terminates
+inside the tab, the relay becomes untrusted infrastructure and the requirement drops from "a relay you
+trust" to "any relay at all". Every later rung inherits that trust model, which is why it is first.
+
+## Hypothesis
+
+Python's `ssl` module can drive a TLS handshake over a socket that is only a byte pipe, and the relay
+can be reduced to exactly that pipe. Two candidate paths, and the campaign has to measure both rather
+than assume one:
+
+1. **CPython's own `ssl`** on the Pyodide build. The blocker to measure first is whether the Pyodide
+   distribution ships a usable `_ssl` at all, and if so whether its OpenSSL can complete a handshake
+   with sockets that are JSPI-suspended rather than real file descriptors.
+2. **WebCrypto-backed TLS in JS**, with Python seeing a plain socket. This trades a large surface
+   (a TLS 1.3 record layer over `crypto.subtle`) for not depending on the engine's OpenSSL.
+
+If both fail, the failure is specific and worth recording: it names which layer cannot terminate TLS
+without a real file descriptor, and that is the finding.
+
+## Probes
+
+| Probe | What it measures | Status |
+|---|---|---|
+| `sslSurfaceProbe.html` | Whether the engine's `ssl` can drive a real handshake: module presence, `SSLContext`, `wrap_socket`, and trust roots | measured, and it kills path 1 |
+
+The order was deliberate: measure the engine's `ssl` before writing any relay code. It paid on the
+first probe.
+
+### Measured (2026-08-01, Edge headless)
+
+```
+ssl module        found
+SSLContext        ok: OPENSSL_VERSION = "OpenSSL (stub)"
+capabilities      wrap, verify, nocerts
+```
+
+**Path 1 is dead.** Pyodide ships an `ssl` module whose OpenSSL is a stub, and
+`create_default_context().get_ca_certs()` is empty - there are no trust roots in the distribution.
+`wrap_socket` exists and `verify_mode` defaults to `CERT_REQUIRED`, which is exactly the trap: the
+surface looks complete enough that a naive attempt would appear to work right up until a handshake,
+and would then either fail obscurely or - worse, if someone "fixed" it by setting `CERT_NONE` - do
+unverified TLS while reporting success. Graduation gate 2 exists to catch precisely that shape.
+
+So the campaign's remaining question is path 2 only, and it now carries a second requirement the
+original framing missed: **where do the trust roots come from?** A TLS 1.3 record layer over
+`crypto.subtle` still needs a certificate chain to validate against, and the browser will not lend
+its own root store to page script. The honest candidates are a vendored root bundle shipped as an
+asset with its own provenance entry (the `assetCatalog.json` discipline already covers this shape),
+or pinning per consumer. Neither is free, and the next probe has to measure the cost before any
+record-layer code is written - the same order that just paid.
+
+## 졸업 게이트
+
+Move to `src/` only when all of these hold, measured in a real browser:
+
+1. **The relay never sees plaintext.** A relay instrumented to log everything it forwards records only
+   ciphertext for an `https://` request that Python completes successfully.
+2. **The certificate is actually verified.** A handshake against a host whose certificate does not
+   validate fails, and it fails with a Python-level error a consumer can catch - not a hang, and not a
+   silent downgrade to plaintext.
+3. **`urllib` is unmodified.** The same consumer code that works today keeps working: the surface is
+   `socket`, not a new API.
+4. **The cost is stated.** Handshake latency and per-request overhead against the current
+   relay-terminated path, measured on the same page, recorded here.
+5. **The hermetic lane still holds.** `npm run test:socket` (relay plus a local origin, no traffic
+   leaves the machine) covers the new path too, so the surface does not lose its CI gate to gain TLS.
+
+Closing the campaign deletes this folder; the record lives in the ledger and in git history.

tests/attempts/inTabTls/sslSurfaceProbe.html

@@ -0,0 +1,86 @@
+<!doctype html>
+<!--
+캠페인의 첫 측정. 릴레이 코드를 한 줄도 쓰기 전에 답해야 하는 질문이다: 이 엔진의 파이썬이
+TLS를 스스로 할 수 있는가? CPython의 ssl이 살아 있으면 경로 2(JS에서 TLS 1.3 레코드 층을
+직접 구현)는 통째로 불필요하고, 없으면 경로 1이 죽는다. 어느 쪽이든 이 한 페이지가 가른다.
+-->
+<html lang="ko">
+<head>
+  <meta charset="utf-8">
+  <title>probe: python ssl surface</title>
+  <style>body{font:14px/1.5 system-ui;margin:2rem;max-width:62rem}pre{background:#f4f4f5;padding:1rem;border-radius:8px;white-space:pre-wrap}</style>
+  <script>
+    window.addEventListener("error", (event) => {
+      fetch("/gateReport", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ok: false, checks: [{ name: "module 초기화", pass: false, info: event.message }] }) }).catch(() => {});
+    });
+  </script>
+</head>
+<body>
+<h1>파이썬 ssl 표면</h1>
+<pre id="out">실행 중...</pre>
+<script type="module">
+  import { boot } from "/index.js";
+
+  const out = document.getElementById("out");
+  const checks = [];
+  const check = (name, pass, info = "") => {
+    checks.push({ name, pass: !!pass, info: String(info) });
+    out.textContent += `\n${pass ? "PASS" : "FAIL"} ${name}${info ? ` (${info})` : ""}`;
+  };
+  const report = async () => {
+    const ok = checks.length > 0 && checks.every((entry) => entry.pass);
+    try { await fetch("/gateReport", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ok, checks }) }); } catch (error) {}
+  };
+
+  const params = new URLSearchParams(location.search);
+  try {
+    const machine = await boot({ ...(params.get("indexURL") ? { indexURL: params.get("indexURL") } : {}) });
+    const rt = machine.runtime;
+
+    // (1) ssl 모듈이 import되는가. 이것이 없으면 경로 1(CPython 자체 TLS)은 즉시 죽는다.
+    const importReport = String(rt.run([
+      "import importlib.util as _u",
+      "spec = _u.find_spec('ssl')",
+      "'found' if spec is not None else 'missing'",
+    ].join("\n")));
+    check("ssl 모듈이 배포에 있다", importReport === "found", importReport);
+
+    // (2) 실제로 import되고 SSLContext를 만들 수 있는가(스펙 존재와 동작은 다른 사실이다).
+    const contextReport = String(rt.run([
+      "def probeSslContext():",
+      "    try:",
+      "        import ssl",
+      "        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)",
+      "        return 'ok:' + ssl.OPENSSL_VERSION",
+      "    except BaseException as error:",
+      "        return type(error).__name__ + ': ' + str(error)[:80]",
+      "probeSslContext()",
+    ].join("\n")));
+    check("SSLContext를 만들 수 있다", contextReport.startsWith("ok:"), contextReport);
+
+    // (3) 핸드셰이크에 필요한 것들이 실제로 있는가. wrap_socket과 인증서 검증 스위치가
+    //     없으면 "TLS를 한다"가 아니라 "TLS 흉내를 낸다"가 된다.
+    const capabilityReport = String(rt.run([
+      "def probeSslCapabilities():",
+      "    try:",
+      "        import ssl",
+      "        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)",
+      "        bits = []",
+      "        bits.append('wrap' if hasattr(ctx, 'wrap_socket') else 'nowrap')",
+      "        bits.append('verify' if ctx.verify_mode == ssl.CERT_REQUIRED else 'noverify')",
+      "        bits.append('certs' if ssl.create_default_context().get_ca_certs() else 'nocerts')",
+      "        return ','.join(bits)",
+      "    except BaseException as error:",
+      "        return type(error).__name__ + ': ' + str(error)[:80]",
+      "probeSslCapabilities()",
+    ].join("\n")));
+    check("wrap_socket과 인증서 검증 재료가 있다", capabilityReport === "wrap,verify,certs", capabilityReport);
+
+    await machine.dispose();
+  } catch (error) {
+    check("예외 없음", false, String(error?.message || error).slice(-200));
+  }
+  await report();
+</script>
+</body>
+</html>