@junghanacs/entwurf 0.12.10 → 0.13.1

package/run.sh

@@ -51,6 +51,22 @@ PROVIDER_ID="entwurf"
 # surfaces). Under an installed package it REFUSES rather than falling back to raw
 # .ts — a fallback would just re-raise the fence error with a worse message.
 # check-install-surface pins both halves statically.
+# Release-gate STEP OUTCOME protocol (P1) — loaded LAZILY, never at top level.
+#
+# Only two surfaces need it: `release_gate`, which classifies each step's exit
+# code, and the LIVE smoke wrappers, which return `$ENTWURF_STEP_SKIP_EXIT` when
+# a prerequisite is missing. Both are dev-only. Sourcing it unconditionally at
+# the top made EVERY subcommand depend on `scripts/lib/` being present, and
+# check-fresh-cut-gate I9c caught the consequence immediately: on an installed
+# tree assembled without that path, run.sh died with a bash "No such file"
+# instead of printing the refusal it is supposed to print. An operator verb must
+# never fail on a dev-only dependency, so the load happens where it is used.
+entwurf_require_step_outcome() {
+  [ -n "${ENTWURF_STEP_SKIP_EXIT:-}" ] && return 0
+  # shellcheck source=scripts/lib/step-outcome.sh
+  . "$REPO_DIR/scripts/lib/step-outcome.sh"
+}
+
 run_ts() {
   local rel="$1"; shift
   case "$REPO_DIR" in
@@ -73,7 +89,7 @@ usage() {
   cat <<'EOF'
 Usage:
   ./run.sh setup [project-dir]        # ONE confident install: pnpm install + install + meta-bridge (if native harness) + v2 install smoke (LIVE substrate = release-gate)
-  ./run.sh release-gate [project-dir] [--allow-skip-gemini]  # SINGLE release gate: full static (pnpm check) + the v2-native live gates (v2 matrix/spawn-resume-live, check-bridge, RGG) + the ACP plugin acceptance floor (12 LIVE smokes: socket-citizen/raw-turn/overlay/provider/session-reuse/carrier-augment/memory-containment/rgg/mcp/skill/bundled-mcp/v2-send). TWO-TIER summary: MUST (release-blocking, owns the exit code — "green" applies here) + BEHAVIOR (advisory, non-blocking: RGG positives model-in-loop turn). LIVE-gated MUST steps HONEST-SKIP when LIVE!=1 (a CUT needs LIVE=1, SKIP=0). --allow-skip-gemini accepted-but-ignored (back-compat). final cut authorization is GLG's.
+  ./run.sh release-gate [project-dir] [--cut] [--allow-skip-gemini]  # SINGLE release gate: full static (pnpm check) + the v2-native live gates (v2 matrix/spawn-resume-live, check-bridge, RGG) + the ACP plugin acceptance floor (12 LIVE smokes: socket-citizen/raw-turn/overlay/provider/session-reuse/carrier-augment/memory-containment/rgg/mcp/skill/bundled-mcp/v2-send) + the two axes the aggregate used to omit silently (spawn-live/claude-native-resume; Cortex stays a documented on-demand direct call) + the cross-harness delivery chain (smoke-entwurf-chain-live). TWO-TIER summary: MUST (release-blocking, owns the exit code — "green" applies here) + BEHAVIOR (advisory, non-blocking: RGG positives model-in-loop turn). STEP OUTCOME protocol: every step is INVOKED and reports its own PASS / SKIP (exit 97, a prerequisite it does not have) / FAIL — a skip is never counted as a pass. Without --cut this is the unattended diagnostic (SKIPs reported, exit 0). WITH --cut it is read as release acceptance and ANY MUST SKIP is red, which is what makes "a CUT needs LIVE=1, SKIP=0" executable instead of prose. --allow-skip-gemini accepted-but-ignored (back-compat). final cut authorization is GLG's.
   ./run.sh check-bridge               # entwurf-bridge direct MCP smoke + protocol/negative-path test.sh (live substrate = v2 live smokes)
   ./run.sh check-entwurf-bridge-boot # deterministic gate (5d-5-pre, G1a/G1b, IN pnpm check): boot start.sh under strip-types + assert v2 fence graph loads + entwurf_v2 registered/schema; tools/list only, no auth/side-effect
   ./run.sh check-entwurf-bridge-pi-free # deterministic gate (0.12.1 A, IN pnpm check): static — bridge index eager value-import closure must carry no @earendil-works/pi-* (type-only + dynamic import excluded); proves the meta-bridge boots pi-free
@@ -129,7 +145,11 @@ Usage:
   ./run.sh check-meta-doctor-oracle   # 0.12.8 (#51): detection power of the release ORACLE — healthy fixture must reach `doctor: PASS`, then 21 planted defects (retired shell form, partial hand-patch, launcher bypass/repoint/provenance loss, malformed exec args, owner type drift, extra leaf/group, doorbell asyncRewake/path/timeout, no live bridge, stale receiver, ambiguous/missing cache, missing hook log/writer, failing CLI probes) must each turn it FAIL naming their own cause, plus a positive case pinning that a long-writing CLI is NOT a false negative. Offline/deterministic (deps: bash+node+python3)
   ./run.sh smoke-agy-install-state    # agy MCP + exact permission ownership regression: isolated HOME+XDG, adopt/state/inverse, symlink refuse, setup degrade. Offline/deterministic
   ./run.sh check-agy-permission-matrix # AGY permission CONTRACT SPACE as a literal table (55 cells): parser-state × operation × settings × ownership × precedence with stated exclusion rules; expectations are hand-written literals, never read from the SUT. Offline/deterministic (deps: python3)
+  ./run.sh smoke-entwurf-chain-live    # LIVE cross-harness delivery chain: native Claude Code -> pi GPT -> pi ACP Sonnet -> mailbox terminus, proving sender identity/replyable at every hop and a real read receipt at the end. Prerequisites (claude on PATH, pi credentials per backend) report protocol SKIP, never a pass
+  ./run.sh check-release-gate-outcomes  # release-gate STEP OUTCOME protocol (P1): one skip exit code shared by the shell + TS halves, classifier never rounds a skip up to a pass, `--cut` refuses a MUST SKIP while a bare diagnostic stays exit 0, no LIVE smoke keeps the old exit-0 skip shape, and both real skip surfaces are INVOKED and observed to propagate the code
   ./run.sh check-gate-qualification    # kill-proof qualification (the gate-of-gates): runner self-test (classifier truth table + synthetic negatives incl. wrong-reason/hang/control-red/impurity) + committed mutant manifests (scripts/mutants/*.json) run in an isolated snapshot repo under control→mutant→restore→control; the real checkout is never written. Evidence = claim IDs + killed mutant IDs, never assertion counts
+  ./run.sh check-probe-ordering        # §11-7 ordering-probe deterministic gate: raw-client SAMENESS pinned to backend.ts (sequence/args/timeouts/permission policy — the probe may never measure a lookalike), phase attribution incl. set-model, probe-mode fixture wire markers (delay honored, probeRunId REQUIRED, smoke-acp-mcp-live legacy compat), event-log door integrity (reserved keys refused at write; unknown marker name, broken sort axis, or a payload the classifier cannot judge on is MALFORMED, never a quiet event), and the §11-7 paired-verdict truth table (P0/I0 outside the space, phase-qualified D, B promotion ladder, C, A two-delay rule). Offline/deterministic; kill-proofed via scripts/mutants/probe-ordering.json
+  ./run.sh check-probe-cli-shim        # §11-7-c B-name-snapshot PRODUCER gate: the CLI shim driven as a REAL process against fake CLIs (no API, no cost). Proves what a defect would buy — FABRICATED evidence (a malformed init is never reported as an empty name set; the boot report carries the true target path+sha256 the classifier verifies against the roster), a DESTROYED turn (byte transparency across mid-UTF8/CRLF/oversized/unterminated framing, exit-code fidelity, signal re-raise, inbound signal forwarding, stderr passthrough, stdout backpressure), and LEAKED operator state (exact-allowlist env scrub, no argv/env/prompt body in the log). Offline/deterministic; kill-proofed via scripts/mutants/probe-ordering.json
   ./run.sh smoke-agy-statusline-state # agy ambient garden-id statusLine install/doctor/inverse regression. Offline/deterministic
   ./run.sh smoke-agy-hooks-state      # agy PreInvocation birth/sender hook install/doctor/inverse + direct stdin→meta-record regression. Offline/deterministic
   ./run.sh smoke-user-scope-citizen   # 0.12.6 install-boundary: pi packages[] registration SSOT (register-pi-package.py) — idempotent + preserves unrelated + normalizes stale + remove symmetry + fails loud. Offline/hermetic (deps: bash+python3)
@@ -982,9 +1002,10 @@ smoke_entwurf_v2_spawn_live() {
   # 5c-3a watcher's timeout→kill→child-exited→release integration on a live process. It does
   # NOT spawn a real `pi --entwurf-control` resume (that is the 5d surface matrix). Run once
   # before 5d and record the result:  LIVE=1 ./run.sh smoke-entwurf-v2-spawn-live
+  entwurf_require_step_outcome
   if [ "${LIVE:-}" != "1" ]; then
-    echo "[smoke-entwurf-v2-spawn-live] skipped — set LIVE=1 to run (spawns real children + opens a real unix socket)."
-    return 0
+    echo "[entwurf:skip] smoke-entwurf-v2-spawn-live — set LIVE=1 to run (spawns real children + opens a real unix socket)."
+    return "$ENTWURF_STEP_SKIP_EXIT"
   fi
   run_ts scripts/smoke-entwurf-v2-spawn-live.ts
 }
@@ -1049,6 +1070,18 @@ smoke_acp_memory_containment_live() {
   run_ts scripts/smoke-acp-memory-containment-live.ts
 }
 
+smoke_acp_long_turn_live() {
+  # 0.13.1 LIVE acceptance for the prompt-lifecycle contract — OUT of pnpm check,
+  # needs LIVE=1. Drives ONE real pi provider turn whose tool work (default
+  # 3 x 240s foreground wait) deliberately outlasts the RETIRED 600s prompt cutoff, and
+  # requires it to finish as ONE turn: the nonce arrives, elapsed > 600000ms, the
+  # persisted transcript shows exactly ONE cold ACP bootstrap (no replay), and no
+  # retry/timeout is reported anywhere. Takes >12 minutes by construction.
+  # Overrides: ENTWURF_ACP_LONG_TURN_{MODEL,SLEEP_SECONDS,ROUNDS,HORIZON_MS}.
+  #   LIVE=1 ./run.sh smoke-acp-long-turn-live
+  run_ts scripts/smoke-acp-long-turn-live.ts
+}
+
 smoke_acp_provider_live() {
   # S2c acceptance smoke (ACP plugin on v2) — OUT of pnpm check, needs LIVE=1.
   # Drives the REAL pi PROVIDER path end to end: a real `pi` loads this
@@ -1177,6 +1210,41 @@ smoke_acp_rgg_live() {
   (cd "$REPO_DIR" && ENTWURF_LIVE_TARGET="$target" SMOKE_RGG_POSITIVE=0 bash scripts/smoke-resident-garden-guard.sh)
 }
 
+smoke_acp_cortex_live() {
+  # On-demand LIVE smoke for the Cortex (Snowflake Cortex Code) ACP backend — the
+  # first NON-claude adapter on the rail (docs/acp-backend-rail.md, Cortex audit). OUT of
+  # `pnpm check` AND OUTSIDE the claude-only aggregate LIVE floor (capability
+  # dignity, invariant #7): a host with no cortex install / no Snowflake auth must
+  # not redden a release for a backend it does not run, so this is deliberately
+  # absent from release-gate's 11-smoke ACP acceptance floor. That is a WIRING
+  # decision, not a lower evidence bar — a cut that SHIPS cortex still owes a
+  # deliberate run of this smoke, and the aggregate gate's silence is not a pass
+  # (ACP rail Cortex verification boundary). Drives one real
+  # cortex ACP turn through the entwurf provider path (outbound entwurf_v2 +
+  # dual-HOME overlay facts + process-group reclaim — CP2).
+  # HONEST-SKIP (exit 0) when LIVE!=1 OR `cortex` is not on PATH OR no
+  # connection is pinned — the live turn needs `cortex` installed with the
+  # operator's own web-login auth already present (there is no `cortex auth`
+  # subcommand — CP0 D6), reached through the overlay's narrow credential
+  # symlinks — narrow in WHICH paths are reachable (D5), not read-only: a symlink
+  # carries no write protection (AGENTS §ACP Plugin Boundary: entwurf never
+  # provides/proxies the Snowflake credential). The connection must ride the adapter seam
+  # (ENTWURF_ACP_CORTEX_CONNECTION) because the dual-HOME overlay denies the
+  # operator settings.json where a default would live. PR #40 called this
+  # `smoke-cortex`; the canonical family name is smoke-acp-cortex-live.
+  #   LIVE=1 ENTWURF_ACP_CORTEX_CONNECTION=<conn> ./run.sh smoke-acp-cortex-live
+  entwurf_require_step_outcome
+  if [ "${LIVE:-}" != "1" ]; then
+    echo "[entwurf:skip] smoke-acp-cortex-live — set LIVE=1 (+ ENTWURF_ACP_CORTEX_CONNECTION) to run."
+    return "$ENTWURF_STEP_SKIP_EXIT"
+  fi
+  if ! command -v cortex >/dev/null 2>&1; then
+    echo "[entwurf:skip] smoke-acp-cortex-live — cortex not on PATH (install Snowflake Cortex Code and complete its own login flow)."
+    return "$ENTWURF_STEP_SKIP_EXIT"
+  fi
+  run_ts scripts/smoke-acp-cortex-live.ts
+}
+
 smoke_entwurf_v2_matrix_live() {
   # LIVE sentinel for 0.11 Stage 0 step 5d-5 (D4-b) — kept OUT of `pnpm check`. The deterministic
   # sibling (check-entwurf-v2-matrix) fixes every (target kind → transport → lock) cell over fakes
@@ -1189,9 +1257,10 @@ smoke_entwurf_v2_matrix_live() {
   # stay deterministic. Honest skip when LIVE!=1 so the release-gate is runnable unattended.
   # Model: ENTWURF_LIVE_TARGET=<provider>/<model> (default openai-codex/gpt-5.4).
   #   LIVE=1 ./run.sh smoke-entwurf-v2-matrix-live
+  entwurf_require_step_outcome
   if [ "${LIVE:-}" != "1" ]; then
-    echo "[smoke-entwurf-v2-matrix-live] skipped — set LIVE=1 to run (spawns a real pi --entwurf-control + opens a real socket)."
-    return 0
+    echo "[entwurf:skip] smoke-entwurf-v2-matrix-live — set LIVE=1 to run (spawns a real pi --entwurf-control + opens a real socket)."
+    return "$ENTWURF_STEP_SKIP_EXIT"
   fi
   run_ts scripts/smoke-entwurf-v2-matrix-live.ts
 }
@@ -1211,9 +1280,10 @@ smoke_entwurf_v2_spawn_resume_live() {
   # Model: ENTWURF_LIVE_TARGET=<provider>/<model> (default openai-codex/gpt-5.4);
   #        ENTWURF_SPAWN_RESUME_ASSISTANT_TIMEOUT_MS (default 180000).
   #   LIVE=1 ./run.sh smoke-entwurf-v2-spawn-resume-live
+  entwurf_require_step_outcome
   if [ "${LIVE:-}" != "1" ]; then
-    echo "[smoke-entwurf-v2-spawn-resume-live] skipped — set LIVE=1 to run (spawns a real pi resume child + opens a real socket)."
-    return 0
+    echo "[entwurf:skip] smoke-entwurf-v2-spawn-resume-live — set LIVE=1 to run (spawns a real pi resume child + opens a real socket)."
+    return "$ENTWURF_STEP_SKIP_EXIT"
   fi
   run_ts scripts/smoke-entwurf-v2-spawn-resume-live.ts
 }
@@ -1436,12 +1506,13 @@ assert.equal(peerTui, piAi,
 // floor tracks the devDep pin so a consumer can't install against a pi lacking
 // the public trust exports the bridge imports at the pinned minor, AND an upper
 // bound at the next minor stops a fresh install from silently pulling a future
-// pi (past the declared ceiling — 0.83+ at the current 0.82.1 pin) whose
+// pi (past the declared ceiling — 0.84+ at the current 0.83.0 pin) whose
 // internal export surface has drifted from the one we typecheck against.
 // pi moves its public surface every minor (the 0.79→0.80 getModels→provider-
 // factory churn is exactly this), so an open `>=` floor is exactly how the next
-// installer re-acquires the drift. Expected
-// shape: `>=<devDep> <0.<minor+1>` (e.g. `>=0.82.1 <0.83`).
+// installer re-acquires the drift. The floor is also the HARD MINIMUM a consumer
+// install resolves: at `>=0.83.0` an existing 0.82.x host is upgraded, not kept.
+// Expected shape: `>=<devDep> <0.<minor+1>` (e.g. `>=0.83.0 <0.84`).
 const [piMaj, piMin] = piAi.split('.').map(Number);
 assert.equal(piMaj, 0,
   `pi pin major must stay 0 for the next-minor ceiling rule (got ${piAi}); revisit check-dep-versions when pi reaches 1.x`);
@@ -2211,19 +2282,23 @@ EOF
 }
 
 check_acp_provider_surface() {
-  # Deterministic gate for the S0 ACP provider loader/fence slice. Loads the REAL
-  # provider lib modules and asserts the registration surface: one surface name,
-  # curated Claude anchor present with full ProviderModelConfig rows, no-auth
-  # sentinel shape, and a FAIL-LOUD streamSimple (calling it throws — no native
-  # fallback, no empty-but-successful stream). Pure, no pi runtime, no API.
-  section "ACP provider surface (S0 loader/fence)"
+  # Deterministic gate for the ACP provider registration surface. Loads the REAL
+  # provider lib modules AND compiles + drives the REAL entry against a fake pi,
+  # asserting: one surface name, the no-auth sentinel shape, full
+  # ProviderModelConfig rows on the curated claude anchor, the EXACT curated model
+  # set both adapters contribute (claude 2 + cortex 4 —
+  # [QK:CORTEX-PROVIDER-SIX-ROW-SURFACE], the claim that catches an entry which
+  # silently drops a whole backend), and that streamSimple is the real
+  # streamShellAcp backend (checked BY NAME, never invoked — invoking spawns an
+  # ACP child). Pure, no pi runtime, no API.
+  section "ACP provider surface (registration + both-adapter model set)"
   run_ts scripts/check-acp-provider-surface.ts
 }
 
 check_acp_sdk_surface() {
   # Deterministic gate for the S2a ACP SDK dependency surface. Pins the three
   # ACP runtime deps to the current oracle versions (@agentclientprotocol/sdk
-  # 1.3.0 + claude-agent-acp 0.62.0 + @anthropic-ai/sdk 0.100.1), locks the
+  # 1.3.0 + claude-agent-acp 0.64.0 + @anthropic-ai/sdk 0.100.1), locks the
   # peer-resolution that keeps claude-agent-sdk satisfiable (0.100.1, not the
   # stale 0.91.1), asserts the wire SDK still value-exports the symbols the raw
   # turn needs (silent-rename gate), and forbids any source-level anthropic SDK
@@ -2268,6 +2343,37 @@ check_acp_event_mapper() {
   run_ts scripts/check-acp-event-mapper.ts
 }
 
+check_acp_stop_reason() {
+  # Deterministic gate for the ACP stop-reason contract. Drives every member of
+  # the closed ACP terminal set (end_turn / max_tokens / max_turn_requests /
+  # refusal / cancelled), plus an unrecognized reason and an ABSENT one, end to
+  # end through streamAcpTurn against a fake connection — asserting the event
+  # kind, the event reason, and the final message's stopReason / rawStopReason /
+  # errorMessage together. Forbids the collapse-to-"stop" default that reported
+  # refusals and exhausted turn budgets as finished answers. Also pins the
+  # "pending" seed on the freshly created stream state.
+  section "ACP stop reason (terminal set → pi verdict)"
+  run_ts scripts/check-acp-stop-reason.ts
+}
+
+check_acp_prompt_lifecycle() {
+  # Deterministic gate for the ACP prompt LIFECYCLE contract. A prompt has no
+  # wall-clock cutoff: it ends when it resolves, when the operator aborts, or
+  # when the child dies / its stdio ends. Drives streamAcpTurn against a fake
+  # ACP child + connection for eight cells — a quiet in-flight turn is not
+  # sealed and later completes on its ORIGINAL prompt; an abort sends ACP
+  # session/cancel first (cancelled→aborted, no signal to a cooperating child);
+  # a wedged agent is torn down after the bounded grace and still returns; a
+  # mid-prompt child death reports exit status + stderr tail on BOTH the new and
+  # the reuse path; a death BETWEEN turns is announced once by the next turn
+  # while a teardown WE performed stays silent — plus pi's own
+  # isRetryableAssistantError as
+  # the oracle that our prompt-phase failure text is not a transient
+  # (cold-replay) error.
+  section "ACP prompt lifecycle (no wall clock; abort/child-death endings)"
+  run_ts scripts/check-acp-prompt-lifecycle.ts
+}
+
 check_acp_prompt_builder() {
   # Deterministic gate for the S2d bootstrapPath-scoped ACP prompt builder (핀4).
   # Proves prompt SCOPE follows bootstrapPath: new=full transcript (history
@@ -2340,6 +2446,33 @@ check_acp_carrier_augment() {
   run_ts scripts/check-acp-carrier-augment.ts
 }
 
+check_acp_cortex() {
+  # Deterministic gate for the Cortex (Snowflake Cortex Code) ACP backend — the
+  # first non-claude adapter on the rail, landed 0.13.0 on the CP0-measured
+  # contract (docs/acp-backend-rail.md, Cortex audit D1–D10). The cortex source is one
+  # `cortexAdapter` object (backend-adapter.ts) + its curated surface (models.ts)
+  # + the dual-HOME overlay (overlay.ts); the 결합 규칙 requires the gate to land
+  # WITH it, extending the check-acp-* family, so cortex's whole
+  # deterministic axis lives here. Locks (each Cortex-audit D-pinned): the GLG-decided
+  # 4-row curation rides real registry bases and the `cortex-` prefix routes to
+  # cortexAdapter; launch is `cortex acp serve` with NO -m — the model is
+  # enforced per turn via session/set_config_option with the native id (E);
+  # CORTEX_HOME presence (empty included) refuses the spawn (D3); the dual-HOME
+  # overlay isolates HOME+SNOWFLAKE_HOME per session key (P0-1: scope =
+  # backend-passed resolveSessionKey, never ambient), passes through only
+  # connections.toml / optional config.toml / credential_cache (D5/F — never the
+  # whole cache, never skills; symlink-through, no copies — AGENTS §ACP Plugin
+  # Boundary), authors autoUpdate:false (D4), and projects envelope-enriched
+  # explicit servers into cortex/mcp.json with the real HOME restored on
+  # entwurf-bridge alone (D9/D10), non-stdio failing loud; the
+  # CORTEX_ACP_COMMAND override single-quotes shell-metachar connection tokens.
+  # The gate self-manages the tsc-emit layer for the .js-suffixed backend-adapter
+  # imports; no auth, no spawn, no live cortex needed. Kill-qualified via the
+  # `acp-cortex` mutant lane under check-gate-qualification.
+  section "ACP cortex backend (Snowflake Cortex Code — 1st non-claude adapter)"
+  run_ts scripts/check-acp-cortex.ts
+}
+
 check_pack() {
   # Dry-run tarball invariant gate for the public npm surface.
   #
@@ -2709,21 +2842,21 @@ _check_pack_install_impl() {
   printf '%s\n' '{ "name": "entwurf-install-smoke", "version": "0.0.0", "private": true }' > "$tmp/package.json"
 
   # pi-agent-core is pinned even though we never import it: pi-coding-agent depends
-  # on it by CARET (`^0.82.1`), so with no lockfile in this fresh temp project it
+  # on it by CARET (`^0.83.0`), so with no lockfile in this fresh temp project it
   # floats to whatever pi published last — and that newer core then drags a NESTED
   # pi-ai of its own. Measured 2026-07-21: pinning only the three we import left
   # pi-agent-core@0.80.10 + pi-ai@0.80.10 in the tree while the gate still announced
   # "pinned pi 0.80.7". The gate would then be verifying an UNVERIFIED runtime — the
   # exact class this cut exists to close. Pin every @earendil-works package that
   # constitutes the pi runtime, not just the ones whose types we touch.
-  echo "[check-pack-install] pnpm add into $tmp (with 0.82.x peers + typebox)"
+  echo "[check-pack-install] pnpm add into $tmp (with 0.83.x peers + typebox)"
   local install_log
   install_log=$(cd "$tmp" && pnpm add \
     "$tgz_path" \
-    "@earendil-works/pi-ai@0.82.1" \
-    "@earendil-works/pi-coding-agent@0.82.1" \
-    "@earendil-works/pi-tui@0.82.1" \
-    "@earendil-works/pi-agent-core@0.82.1" \
+    "@earendil-works/pi-ai@0.83.0" \
+    "@earendil-works/pi-coding-agent@0.83.0" \
+    "@earendil-works/pi-tui@0.83.0" \
+    "@earendil-works/pi-agent-core@0.83.0" \
     "typebox@latest" \
     --ignore-workspace --ignore-scripts 2>&1) || {
     fail "[check-pack-install] pnpm add failed:"
@@ -2733,17 +2866,17 @@ _check_pack_install_impl() {
 
   # A pin is a wish until the resolved tree is read back. Assert it: EVERY
   # @earendil-works pi package present — direct or transitive, top level or nested —
-  # must be the pinned 0.82.1. Anything else means an unpinned caret floated and the
+  # must be the pinned 0.83.0. Anything else means an unpinned caret floated and the
   # rest of this gate would be exercising a runtime nobody verified, while still
-  # printing "pinned pi 0.82.1". Fail loud instead of proving the wrong floor.
+  # printing "pinned pi 0.83.0". Fail loud instead of proving the wrong floor.
   local leaked_pi
-  leaked_pi=$(ls "$tmp/node_modules/.pnpm" 2>/dev/null | grep '^@earendil-works+pi-' | grep -v '@0\.82\.1' || true)
+  leaked_pi=$(ls "$tmp/node_modules/.pnpm" 2>/dev/null | grep '^@earendil-works+pi-' | grep -v '@0\.83\.0' || true)
   if [ -n "$leaked_pi" ]; then
-    fail "[check-pack-install] UNVERIFIED pi runtime resolved into the install tree (expected only 0.82.1):"
+    fail "[check-pack-install] UNVERIFIED pi runtime resolved into the install tree (expected only 0.83.0):"
     printf '%s\n' "$leaked_pi" | sed 's/^/    /' >&2
     return 1
   fi
-  echo "[check-pack-install] pi runtime tree pin verified: every @earendil-works pi package is 0.82.1"
+  echo "[check-pack-install] pi runtime tree pin verified: every @earendil-works pi package is 0.83.0"
 
   # Resolve the installed package.json and confirm pi.extensions
   # arrived intact. If pi.extensions is empty or missing, the
@@ -2824,18 +2957,45 @@ _check_pack_install_impl() {
     echo "$loader_out" | tail -10 | sed 's/^/    /' >&2
     return 1
   fi
-  # Verify the full curated Claude surface is visible: the Sonnet row AND the
-  # opus anchor (CURATED_ANCHOR_MODEL_ID in lib/acp/models.ts — the model whose
-  # absence is a hard registry regression). Checking only one would let half the
-  # surface drop silently.
-  for anchor in "claude-sonnet-5" "claude-opus-5"; do
-    if ! grep -q "$anchor" <<<"$loader_out"; then
-      fail "[check-pack-install] pi loader output missing curated Claude model $anchor:"
-      echo "$loader_out" | tail -10 | sed 's/^/    /' >&2
-      return 1
-    fi
-  done
-  echo "[check-pack-install] pi loader smoke pass (entwurf registered, claude-sonnet-5 + claude-opus-5 anchor)"
+  # Verify the EXACT curated surface the installed package registers — both
+  # backends (claude 2 rows + cortex 4 rows = 6), as a SET, not as anchors.
+  #
+  # Why exact-set and not `grep -q <id>`: the cortex ids CONTAIN the claude ids
+  # as substrings (`cortex-claude-sonnet-5` matches a bare `claude-sonnet-5`
+  # grep), so a substring probe could go green on a surface that dropped every
+  # unprefixed Claude row. And an anchor-only probe cannot see a MISSING cortex
+  # row at all — that is exactly the installed-consumer gap this assertion
+  # closes: the source-side sets are pinned by check-acp-cortex /
+  # check-acp-provider-surface, but only THIS gate proves the ids survive the
+  # pack → install → pi-loader path into a real consumer's model list.
+  #
+  # Parse rows whose FIRST field is the provider `entwurf` (pi prints a
+  # `provider model context …` table; the header row's first field is
+  # `provider`, so it drops out) and take the second field as the model id.
+  local loader_ids loader_expected
+  loader_ids=$(awk '$1 == "entwurf" { print $2 }' <<<"$loader_out" | LC_ALL=C sort)
+  loader_expected=$(printf '%s\n' \
+    claude-opus-5 \
+    claude-sonnet-5 \
+    cortex-auto \
+    cortex-claude-opus-5 \
+    cortex-claude-sonnet-5 \
+    cortex-openai-gpt-5.4 | LC_ALL=C sort)
+  if [ "$loader_ids" != "$loader_expected" ]; then
+    fail "[check-pack-install] installed provider model set drifted — expected exactly 6 curated ids (claude 2 + cortex 4):"
+    echo "  expected:" >&2
+    echo "$loader_expected" | sed 's/^/    /' >&2
+    echo "  actual (entwurf rows):" >&2
+    echo "${loader_ids:-<none>}" | sed 's/^/    /' >&2
+    echo "  raw loader output:" >&2
+    echo "$loader_out" | tail -15 | sed 's/^/    /' >&2
+    return 1
+  fi
+  # Name the set on SUCCESS too, not only in the failure branch — same principle as
+  # the pinned-pi version assert above: a gate that cannot name what it proved has
+  # proved nothing, and "6 rows" without the ids cannot be audited from a CI log.
+  echo "[check-pack-install] pi loader smoke pass (entwurf registered; exact 6-row curated set: claude 2 + cortex 4):"
+  echo "$loader_ids" | sed 's/^/    /'
 
   # npm-managed neutral install regression — the README's PRIMARY install path is
   # now `npm install @junghanacs/entwurf` (NOT `pi install npm:...`). This layout
@@ -3663,7 +3823,7 @@ setup_all() {
   # native-harness meta-bridge, so a relocate/clone needs ONE command — not the
   # install + install-meta-bridge two-pronged split that froze the Claude
   # statusLine on the old path (the 2026-06-23 relocation gap). Detection-gated:
-  # a pi-only host with no native harness skips it cleanly (§10 "있으면 설정,
+  # a pi-only host with no native harness skips it cleanly (rail “Shipped adapters” — "있으면 설정,
   # 없으면 담아준다"); meta-bridge-install.sh is itself idempotent.
   if command -v claude >/dev/null 2>&1; then
     section "meta-bridge install (native harness detected: Claude Code)"
@@ -3695,7 +3855,7 @@ setup_all() {
   wire_agy_hooks
 
   # Deterministic preflight lives in `pnpm check`; live substrate acceptance lives
-  # in `LIVE=1 ./run.sh release-gate <scratch>`. Setup is the install path, so it
+  # in `LIVE=1 ./run.sh release-gate <scratch> --cut`. Setup is the install path, so it
   # verifies the installed MCP bridge boundary only and does NOT run the legacy
   # ACP/v1 session-messaging/sentinel gates.
   section "v2 install smoke: entwurf-bridge (direct MCP protocol)"
@@ -3711,7 +3871,7 @@ setup_all() {
     echo "                           ./run.sh doctor-agy-statusline"
     echo "                           ./run.sh doctor-agy-hooks"
   fi
-  echo "Run 'LIVE=1 ./run.sh release-gate <scratch>' for live substrate acceptance."
+  echo "Run 'LIVE=1 ./run.sh release-gate <scratch> --cut' for live substrate acceptance (--cut refuses any MUST SKIP)."
 }
 
 # wire_agy_bridge — detection-gated, NON-FATAL agy (Antigravity) MCP bridge wiring, folded into
@@ -3727,7 +3887,7 @@ wire_agy_bridge() {
   # whatever agy the CI/dev host happens to have — production leaves it unset (= `command -v
   # agy`, no regression). Same override spirit as agy-bridge.sh's AGY_MCP_CONFIG/AGY_BRIDGE_COMMAND.
   if ! command -v "${AGY_BIN:-agy}" >/dev/null 2>&1; then
-    echo "[setup] no agy on PATH — skipping agy bridge wiring (no state; pi/Claude-only host)"
+    echo "[setup] no agy on PATH — skipping agy bridge wiring (no state; this host runs no Antigravity)"
     return 0
   fi
   section "agy bridge install (native harness detected: Antigravity)"
@@ -3780,7 +3940,7 @@ wire_agy_bridge() {
 # stable bin entwurf-agy-statusline, exposed by expose_dev_bin above.
 wire_agy_statusline() {
   if ! command -v "${AGY_BIN:-agy}" >/dev/null 2>&1; then
-    echo "[setup] no agy on PATH — skipping agy statusLine wiring (no state; pi/Claude-only host)"
+    echo "[setup] no agy on PATH — skipping agy statusLine wiring (no state; this host runs no Antigravity)"
     return 0
   fi
   section "agy statusLine install (native harness detected: Antigravity)"
@@ -3818,7 +3978,7 @@ wire_agy_statusline() {
 # garden id after the first invocation.
 wire_agy_hooks() {
   if ! command -v "${AGY_BIN:-agy}" >/dev/null 2>&1; then
-    echo "[setup] no agy on PATH — skipping agy hooks wiring (no state; pi/Claude-only host)"
+    echo "[setup] no agy on PATH — skipping agy hooks wiring (no state; this host runs no Antigravity)"
     return 0
   fi
   section "agy hooks install (native harness detected: Antigravity)"
@@ -3895,10 +4055,18 @@ expose_dev_bin() {
 #   - Final release authorization is GLG's, not this script's: a green
 #     run is necessary, and the operator closes the decision.
 release_gate() {
+  entwurf_require_step_outcome
   local -a positional=()
   local a
+  # --cut is the EXECUTABLE half of "a CUT needs LIVE=1, SKIP=0" (P1). Without it
+  # this stays the unattended diagnostic it has always been: SKIPs are reported
+  # and the run still exits 0. With it, any MUST SKIP is red — including the
+  # LIVE!=1 case, which needs no separate assertion because every LIVE-gated step
+  # then skips on its own and the skip counter blocks.
+  local cut_mode=0
   for a in "$@"; do
     case "$a" in
+      --cut) cut_mode=1 ;;
       --allow-skip-gemini) ;;  # accepted-but-ignored: gemini removed from the claude-only floor (back-compat for existing scripts)
       *) positional+=("$a") ;;
     esac
@@ -3949,27 +4117,36 @@ release_gate() {
   }
 
   # LIVE-gated MUST step: a release-blocking gate that needs a real backend turn
-  # (auth/model/credit). When LIVE!=1 it is an HONEST SKIP — counted as SKIP, NOT
-  # PASS — so an unattended `./run.sh release-gate` stays runnable without faking
-  # coverage. A release CUT therefore requires `LIVE=1 ./run.sh release-gate
-  # <scratch>` to land MUST PASS with SKIP=0; a green run that still shows SKIP is
-  # CI safety, never live acceptance. (Same rule the v2 substrate sentinels below
-  # spell out inline; this helper applies it to the ACP plugin acceptance floor.)
+  # (auth/model/credit). It is ALWAYS INVOKED and the step itself reports whether
+  # it could run — that is the whole point of P1. The old shape asked `LIVE=1?`
+  # here and skipped without calling, which meant the summary asserted a skip it
+  # had never confirmed, while a step that WAS called could still exit 0 on a
+  # missing prerequisite (Cortex without a connection) and be counted PASS.
+  # Now one protocol decides: exit 0 = PASS, $ENTWURF_STEP_SKIP_EXIT = SKIP,
+  # anything else = FAIL. A SKIP is never rounded up, and `--cut` refuses any.
+  #
+  # `LIVE` is NOT forced here — it rides the operator's environment into the
+  # child, so `LIVE=1 ./run.sh release-gate` runs the step for real and a bare
+  # invocation gets the step's own honest skip.
   run_live_step() {
     local name="$1"; shift
     section "release-gate step: $name"
-    if [ "${LIVE:-}" = "1" ]; then
-      if "$@"; then
+    local rc=0
+    "$@" || rc=$?
+    case "$(entwurf_step_outcome "$rc")" in
+      PASS)
         ok "$name: PASS"
         results+=("PASS  $name"); pass=$((pass + 1))
-      else
-        fail "$name: FAIL"
+        ;;
+      SKIP)
+        warn "$name: SKIP — the step declined a prerequisite it does not have (see its [entwurf:skip] line above). NOT a live acceptance."
+        results+=("SKIP  $name"); skip=$((skip + 1))
+        ;;
+      *)
+        fail "$name: FAIL (exit $rc)"
         results+=("FAIL  $name"); failc=$((failc + 1))
-      fi
-    else
-      warn "$name: LIVE!=1 — skipped (opt-in: needs auth/model — NOT a live acceptance run)"
-      results+=("SKIP  $name (LIVE!=1)"); skip=$((skip + 1))
-    fi
+        ;;
+    esac
   }
 
   # BEHAVIOR lane (0.11.0, GLG+GPT+Opus): a SEPARATE advisory counter for
@@ -3993,19 +4170,32 @@ release_gate() {
   # deterministic/programmatic must-pass gates above (check-entwurf-v2-*,
   # check-bridge) — this lane is autonomous-tool-selection *behavior*, not
   # *function*. Residual bypass → 0.11.x usability lane.
-  local behavior_pass=0 behavior_failc=0
+  # The lane speaks the same STEP OUTCOME protocol (P1) so a missing prerequisite
+  # here is a BEHAVIOR-SKIP, not a fabricated BEHAVIOR-PASS or a misread
+  # BEHAVIOR-FAIL. Advisory semantics are untouched: none of these counters ever
+  # reaches `failc`, and `--cut` reads the MUST skip counter only.
+  local behavior_pass=0 behavior_failc=0 behavior_skip=0
   local -a behavior_results=()
 
   run_behavior_step() {
     local name="$1"; shift
     section "release-gate BEHAVIOR step (advisory, non-blocking): $name"
-    if "$@"; then
-      ok "$name: BEHAVIOR-PASS"
-      behavior_results+=("BEHAVIOR-PASS  $name"); behavior_pass=$((behavior_pass + 1))
-    else
-      warn "$name: BEHAVIOR-FAIL (advisory — model-in-loop signal; S7=Bash-bypass stays hard-fail here; NOT a cut blocker)"
-      behavior_results+=("BEHAVIOR-FAIL  $name"); behavior_failc=$((behavior_failc + 1))
-    fi
+    local rc=0
+    "$@" || rc=$?
+    case "$(entwurf_step_outcome "$rc")" in
+      PASS)
+        ok "$name: BEHAVIOR-PASS"
+        behavior_results+=("BEHAVIOR-PASS  $name"); behavior_pass=$((behavior_pass + 1))
+        ;;
+      SKIP)
+        warn "$name: BEHAVIOR-SKIP — prerequisite absent (advisory lane; not a signal either way)"
+        behavior_results+=("BEHAVIOR-SKIP  $name"); behavior_skip=$((behavior_skip + 1))
+        ;;
+      *)
+        warn "$name: BEHAVIOR-FAIL (advisory — model-in-loop signal; S7=Bash-bypass stays hard-fail here; NOT a cut blocker)"
+        behavior_results+=("BEHAVIOR-FAIL  $name"); behavior_failc=$((behavior_failc + 1))
+        ;;
+    esac
   }
 
   # 1. Static floor (deterministic; includes the two folded gates).
@@ -4043,41 +4233,20 @@ release_gate() {
   # production runEntwurfV2 deps + real pi control-socket RPC + real mailbox enqueue + v2 lock, not
   # per-backend model behavior). Placed right after check-bridge: the MCP/protocol substrate must be
   # green first so a matrix-live failure reads as "v2 transport/lock/enqueue", not bridge basics.
-  # Opt-in LIVE: it spawns a real `pi --entwurf-control` (needs auth/model), so LIVE!=1 is an HONEST
-  # SKIP (not a PASS) — an unattended release-gate stays runnable without faking coverage. Independent
-  # of --allow-skip-gemini (now a no-op back-compat flag on the claude-only floor; this gates substrate auth).
-  section "release-gate step: smoke-entwurf-v2-matrix-live"
-  if [ "${LIVE:-}" = "1" ]; then
-    if gate env LIVE=1 bash "$self" smoke-entwurf-v2-matrix-live; then
-      ok "smoke-entwurf-v2-matrix-live: PASS"
-      results+=("PASS  smoke-entwurf-v2-matrix-live"); pass=$((pass + 1))
-    else
-      fail "smoke-entwurf-v2-matrix-live: FAIL"
-      results+=("FAIL  smoke-entwurf-v2-matrix-live"); failc=$((failc + 1))
-    fi
-  else
-    warn "smoke-entwurf-v2-matrix-live: LIVE!=1 — skipped (v2 substrate sentinel, opt-in: needs auth/model)"
-    results+=("SKIP  smoke-entwurf-v2-matrix-live (LIVE!=1)"); skip=$((skip + 1))
-  fi
+  # Opt-in LIVE: it spawns a real `pi --entwurf-control` (needs auth/model), so a missing
+  # prerequisite is an HONEST SKIP (not a PASS) — an unattended release-gate stays runnable without
+  # faking coverage. Independent of --allow-skip-gemini (now a no-op back-compat flag on the
+  # claude-only floor; this gates substrate auth). It used to carry its own inline copy of the
+  # PASS/FAIL/SKIP branch; P1 folded it onto `run_live_step` so there is exactly ONE classifier —
+  # a second copy is how a lane silently keeps counting a skip as a pass.
+  run_live_step "smoke-entwurf-v2-matrix-live (D4-c: v2 dispatch substrate sentinel)" gate bash "$self" smoke-entwurf-v2-matrix-live
   # 0.11.0 (A) acceptance: the FULL spawn-bg resident lifecycle — a real `pi` resume child stands
   # its control socket up, does a model turn, lock released ×1. Placed right after matrix-live (the
   # transport sentinel): a spawn-resume failure then reads as "resume/resident lifecycle", not
-  # transport basics. Same opt-in LIVE rule — LIVE!=1 is an HONEST SKIP (model-in-loop, needs
-  # auth/model). NOTE: a 0.11.0 tag REQUIRES `LIVE=1 ./run.sh release-gate` (or this step direct)
-  # to PASS — the SKIP is CI safety, never acceptance.
-  section "release-gate step: smoke-entwurf-v2-spawn-resume-live"
-  if [ "${LIVE:-}" = "1" ]; then
-    if gate env LIVE=1 bash "$self" smoke-entwurf-v2-spawn-resume-live; then
-      ok "smoke-entwurf-v2-spawn-resume-live: PASS"
-      results+=("PASS  smoke-entwurf-v2-spawn-resume-live"); pass=$((pass + 1))
-    else
-      fail "smoke-entwurf-v2-spawn-resume-live: FAIL"
-      results+=("FAIL  smoke-entwurf-v2-spawn-resume-live"); failc=$((failc + 1))
-    fi
-  else
-    warn "smoke-entwurf-v2-spawn-resume-live: LIVE!=1 — skipped (0.11.0 A acceptance, opt-in: needs auth/model)"
-    results+=("SKIP  smoke-entwurf-v2-spawn-resume-live (LIVE!=1)"); skip=$((skip + 1))
-  fi
+  # transport basics. Same opt-in LIVE rule. NOTE: a tag REQUIRES `LIVE=1 ./run.sh release-gate
+  # --cut` (or this step direct) to PASS — a SKIP is CI safety, never acceptance, and `--cut` is
+  # what now enforces that instead of prose.
+  run_live_step "smoke-entwurf-v2-spawn-resume-live (0.11.0 A: full spawn-bg resident lifecycle)" gate bash "$self" smoke-entwurf-v2-spawn-resume-live
 
   # 3b. ACP plugin acceptance floor (S0~S2f live). These prove the ACP plugin's
   #     programmatic transport/provider/backend invariants on the v2 core — NOT
@@ -4092,18 +4261,35 @@ release_gate() {
   #     → first-user augment delivery + empty-carrier billing-clean (핀1) →
   #     ACP-target garden guard (deterministic half). Opt-in LIVE: LIVE!=1 is an
   #     HONEST SKIP via run_live_step (see its note) — a CUT needs LIVE=1, SKIP=0.
-  run_live_step "smoke-acp-socket-citizen-live (S1: turn-free socket citizenship)"        gate env LIVE=1 bash "$self" smoke-acp-socket-citizen-live
-  run_live_step "smoke-acp-raw-turn-live (S2a: pinned ACP pipe + local auth)"             gate env LIVE=1 bash "$self" smoke-acp-raw-turn-live
-  run_live_step "smoke-acp-overlay-live (S2b: config overlay + hooks:{} + tool meta)"     gate env LIVE=1 bash "$self" smoke-acp-overlay-live
-  run_live_step "smoke-acp-provider-live (S2c/S2f: real pi provider path + progress/L3)"  gate env LIVE=1 bash "$self" smoke-acp-provider-live
-  run_live_step "smoke-acp-session-reuse-live (S2d: process-scoped reuse + recall)"       gate env LIVE=1 bash "$self" smoke-acp-session-reuse-live
-  run_live_step "smoke-acp-carrier-augment-live (S2e-1: augment delivery + 핀1 billing)"  gate env LIVE=1 bash "$self" smoke-acp-carrier-augment-live
-  run_live_step "smoke-acp-memory-containment-live (Gate D: no overlay memory leak)"      gate env LIVE=1 bash "$self" smoke-acp-memory-containment-live
-  run_live_step "smoke-acp-rgg-live (S2e-2: ACP-target garden guard, deterministic half)" gate env LIVE=1 bash "$self" smoke-acp-rgg-live
-  run_live_step "smoke-acp-mcp-live (S2g: operator mcpServers reach the live ACP session)"  gate env LIVE=1 bash "$self" smoke-acp-mcp-live
-  run_live_step "smoke-acp-skill-live (S2g: operator skillPlugins reach the live ACP session)" gate env LIVE=1 bash "$self" smoke-acp-skill-live
-  run_live_step "smoke-acp-bundled-mcp-live (S2g axis 3: bundled entwurf-bridge via 0.11.0 resident/RPC circuit)" gate env LIVE=1 bash "$self" smoke-acp-bundled-mcp-live
-  run_live_step "smoke-acp-v2-send-live (S2g axis 4: an ACP model SENDS via entwurf_v2, landing as itself)" gate env LIVE=1 bash "$self" smoke-acp-v2-send-live
+  run_live_step "smoke-acp-socket-citizen-live (S1: turn-free socket citizenship)"        gate bash "$self" smoke-acp-socket-citizen-live
+  run_live_step "smoke-acp-raw-turn-live (S2a: pinned ACP pipe + local auth)"             gate bash "$self" smoke-acp-raw-turn-live
+  run_live_step "smoke-acp-overlay-live (S2b: config overlay + hooks:{} + tool meta)"     gate bash "$self" smoke-acp-overlay-live
+  run_live_step "smoke-acp-provider-live (S2c/S2f: real pi provider path + progress/L3)"  gate bash "$self" smoke-acp-provider-live
+  run_live_step "smoke-acp-session-reuse-live (S2d: process-scoped reuse + recall)"       gate bash "$self" smoke-acp-session-reuse-live
+  run_live_step "smoke-acp-carrier-augment-live (S2e-1: augment delivery + 핀1 billing)"  gate bash "$self" smoke-acp-carrier-augment-live
+  run_live_step "smoke-acp-memory-containment-live (Gate D: no overlay memory leak)"      gate bash "$self" smoke-acp-memory-containment-live
+  run_live_step "smoke-acp-rgg-live (S2e-2: ACP-target garden guard, deterministic half)" gate bash "$self" smoke-acp-rgg-live
+  run_live_step "smoke-acp-mcp-live (S2g: operator mcpServers reach the live ACP session)"  gate bash "$self" smoke-acp-mcp-live
+  run_live_step "smoke-acp-skill-live (S2g: operator skillPlugins reach the live ACP session)" gate bash "$self" smoke-acp-skill-live
+  run_live_step "smoke-acp-bundled-mcp-live (S2g axis 3: bundled entwurf-bridge via 0.11.0 resident/RPC circuit)" gate bash "$self" smoke-acp-bundled-mcp-live
+  run_live_step "smoke-acp-v2-send-live (S2g axis 4: an ACP model SENDS via entwurf_v2, landing as itself)" gate bash "$self" smoke-acp-v2-send-live
+
+  # 3c. The axes the aggregate used to leave out with no stated reason (P2,
+  #     2026-07-31). Three LIVE smokes existed and were simply never wired, so a
+  #     green cut said nothing about them. Under the P1 outcome protocol wiring
+  #     them costs nothing on a host that cannot run them — they SKIP honestly and
+  #     `--cut` names the missing prerequisite — while a host that CAN run them now
+  #     must. Cortex is deliberately NOT here: its rail needs an external Snowflake
+  #     connection the HOST owns, so wiring it would block every cut taken without
+  #     that account; it stays a required DIRECT call for a Cortex-rail cut instead
+  #     (VERIFY 「Cortex is an on-demand axis」). Same for `smoke-acp-long-turn-live`,
+  #     `smoke-agy-native-push-live` and `smoke-acp-ordering-probe-live`: >12min by
+  #     construction, no aggregate-owned agy conversation id, and an opt-in instrument
+  #     rather than acceptance. check-release-gate-outcomes pins that every LIVE smoke
+  #     is either wired here or excluded by a reason the docs still carry.
+  run_live_step "smoke-entwurf-v2-spawn-live (5c-3c: spawn-bg OS substrate on real children/sockets)" gate bash "$self" smoke-entwurf-v2-spawn-live
+  run_live_step "smoke-claude-native-resume-live (native Claude Code resume + meta-bridge neutrality)" gate bash "$self" smoke-claude-native-resume-live
+  run_live_step "smoke-entwurf-chain-live (P3: Claude Code -> pi GPT -> pi ACP Sonnet -> mailbox, identity + receipt)" gate bash "$self" smoke-entwurf-chain-live
 
   # 4. BEHAVIOR lane (advisory, non-blocking). Model-in-loop gates that probe
   #     whether the model AUTONOMOUSLY drives the MCP entwurf surface. These never
@@ -4133,21 +4319,44 @@ release_gate() {
   if [ "${#behavior_results[@]}" -gt 0 ]; then
     printf '    %s\n' "${behavior_results[@]}"
   fi
-  echo "    BEHAVIOR: PASS=$behavior_pass  FAIL=$behavior_failc"
+  echo "    BEHAVIOR: PASS=$behavior_pass  FAIL=$behavior_failc  SKIP=$behavior_skip"
   echo "  (per-step artifact paths are printed in each step's output above)"
   if [ "$behavior_failc" -gt 0 ]; then
     echo ""
     warn "BEHAVIOR FAIL present ($behavior_failc) — advisory model-in-loop signal (e.g. S7 Bash-bypass / entwurf_self not autonomously called). Tracked, NOT a cut blocker; see the 0.11.x usability lane."
   fi
-  # Exit authority = MUST `failc` ONLY. A BEHAVIOR fail never blocks the cut.
-  if [ "$failc" -gt 0 ]; then
+  echo ""
+  if [ "$cut_mode" = "1" ]; then
+    echo "  mode: --cut (a MUST SKIP is a BLOCKER — this run is being read as release acceptance)"
+  else
+    echo "  mode: diagnostic (MUST SKIPs are reported, not blocking — re-run with --cut to read this as acceptance)"
+  fi
+  # The verdict as one greppable token, so release evidence can distinguish a
+  # step that RAN AND BROKE from one that NEVER RAN without reading prose. The
+  # counters above stay literal — a policy block is `FAIL=0 SKIP=n` plus
+  # `BLOCKED (MUST SKIP)`, never a synthesized failure.
+  echo "  $(entwurf_release_verdict "$failc" "$skip" "$cut_mode")"
+
+  # Exit authority — MUST tier only, BEHAVIOR never blocks. The releasable
+  # decision lives in scripts/lib/step-outcome.sh so it is one testable function
+  # rather than a branch re-derived here (and re-derived wrong: the pre-P1 branch
+  # read `failc` alone, so a run with 14 SKIPs still printed "all green").
+  if ! entwurf_release_releasable "$failc" "$skip" "$cut_mode"; then
     echo ""
-    fail "release-gate MUST NOT green — $failc release-blocking step(s) failed. Current release is NOT releasable."
+    if [ "$failc" -gt 0 ]; then
+      fail "release-gate MUST NOT green — $failc release-blocking step(s) failed. Current release is NOT releasable."
+    else
+      fail "release-gate --cut REFUSED — $skip release-blocking step(s) SKIPPED, so this run does not prove they were called."
+      echo "  A skipped step is not acceptance. Supply each missing prerequisite (usually LIVE=1 plus the"
+      echo "  per-step env the [entwurf:skip] lines above name) and re-run, or drop --cut to keep this a diagnostic."
+    fi
     echo "  A green MUST gate is necessary but not sufficient; GLG closes the call."
     return 1
   fi
-  if [ "$behavior_failc" -gt 0 ]; then
-    ok "release-gate MUST PASS (all release-blocking steps green); BEHAVIOR FAIL present (advisory). Necessary condition met — GLG authorizes the cut."
+  if [ "$skip" -gt 0 ]; then
+    warn "release-gate MUST has no failures, but $skip step(s) SKIPPED — this is a DIAGNOSTIC run, not live acceptance. A cut needs \`LIVE=1 ./run.sh release-gate <scratch> --cut\` with SKIP=0."
+  elif [ "$behavior_failc" -gt 0 ]; then
+    ok "release-gate MUST PASS (all release-blocking steps ran and are green); BEHAVIOR FAIL present (advisory). Necessary condition met — GLG authorizes the cut."
   else
     ok "release-gate MUST PASS + BEHAVIOR PASS — all green. Necessary condition met — GLG authorizes the cut."
   fi
@@ -4299,6 +4508,9 @@ case "$cmd" in
   smoke-acp-provider-live)
     smoke_acp_provider_live
     ;;
+  smoke-acp-long-turn-live)
+    smoke_acp_long_turn_live
+    ;;
   smoke-acp-session-reuse-live)
     smoke_acp_session_reuse_live
     ;;
@@ -4311,6 +4523,15 @@ case "$cmd" in
   smoke-acp-bundled-mcp-live)
     smoke_acp_bundled_mcp_live
     ;;
+  smoke-entwurf-chain-live)
+    # P3 — the cross-harness delivery CHAIN on real authenticated rails:
+    # native Claude Code -> pi GPT -> pi ACP Claude Sonnet -> mailbox terminus,
+    # with sender identity at every hop and a read receipt at the end. Needs
+    # `claude` on PATH plus pi credentials for both pi backends; each missing
+    # prerequisite is an honest protocol SKIP, never a pass.
+    #   LIVE=1 ./run.sh smoke-entwurf-chain-live
+    run_ts scripts/smoke-entwurf-chain-live.ts
+    ;;
   smoke-acp-v2-send-live)
     smoke_acp_v2_send_live
     ;;
@@ -4320,6 +4541,9 @@ case "$cmd" in
   smoke-acp-rgg-live)
     smoke_acp_rgg_live
     ;;
+  smoke-acp-cortex-live)
+    smoke_acp_cortex_live
+    ;;
   smoke-acp-socket-citizen-live)
     smoke_acp_socket_citizen_live
     ;;
@@ -4452,6 +4676,37 @@ case "$cmd" in
     # control-red/impurity all must classify red before any real manifest counts.
     run_ts scripts/check-gate-qualification.ts
     ;;
+  check-probe-ordering)
+    # §11-7 ordering-probe gate (docs/acp-backend-rail.md §11-7): the raw-client seam is
+    # only admissible "bound by a gate asserting it issues the same calls, arguments, and
+    # order as the backend's real sequence" — this is that gate. Sameness over a recording
+    # fake + backend.ts SOURCE pins (order/clientInfo/timeouts/permission policy), phase
+    # attribution (set-model included), the probe-mode fixture's wire instrumentation
+    # (real child, raw JSON-RPC, no API), the shared log's contract at its door — envelope
+    # (the evidence line's own runId/marker/sort axis cannot be rewritten by a payload) AND
+    # payload (every field the classifier judges on is typed there) — and the PURE
+    # paired-verdict truth table.
+    run_ts scripts/check-probe-ordering.ts
+    ;;
+  check-probe-cli-shim)
+    # §11-7-c producer gate (docs/acp-backend-rail.md §11-7-c condition 5: "Byte-transparency,
+    # backpressure, and exit/signal propagation are proved by a fake-CLI deterministic gate").
+    # The shim sits on the production spawn path of a paid LIVE turn, so this drives it as a
+    # REAL process against fake CLIs and asks what each defect would buy: fabricated absence
+    # evidence (a malformed init reported as an empty name set, a boot report that does not
+    # name what was actually exec'd), a destroyed turn (mangled bytes, a swallowed signal, a
+    # crash reported as exit 0), or leaked operator state (a prefix env scrub, argv/env/prompt
+    # body in the shared log). No API, no network, no cost.
+    run_ts scripts/check-probe-cli-shim.ts
+    ;;
+  smoke-acp-ordering-probe-live)
+    # §11-7 ordering probe — LIVE paired-run instrument, OUT of pnpm check. Control
+    # (delay=0, must be visible AND callable) + interventions D1/D2 against the SAME
+    # pins/config/fixture; classifies A/A-withheld/B/C/D-<phase> or P0/I0, preserves
+    # the shared NDJSON log + classification under .probe-artifacts/ (gitignored).
+    #   LIVE=1 ./run.sh smoke-acp-ordering-probe-live
+    run_ts scripts/smoke-acp-ordering-probe-live.ts
+    ;;
   smoke-agy-statusline-state)
     # #46 Task 1 regression gate for the agy statusLine install adapter: install→doctor→uninstall
     # in an ISOLATED HOME+XDG with a fake stable bin (entwurf-agy-statusline) + fake pgrep —
@@ -4706,6 +4961,12 @@ case "$cmd" in
   check-acp-event-mapper)
     check_acp_event_mapper
     ;;
+  check-acp-stop-reason)
+    check_acp_stop_reason
+    ;;
+  check-acp-prompt-lifecycle)
+    check_acp_prompt_lifecycle
+    ;;
   check-acp-prompt-builder)
     check_acp_prompt_builder
     ;;
@@ -4721,9 +4982,15 @@ case "$cmd" in
   check-acp-session-reuse)
     check_acp_session_reuse
     ;;
+  check-release-gate-outcomes)
+    run_ts scripts/check-release-gate-outcomes.ts
+    ;;
   check-acp-carrier-augment)
     check_acp_carrier_augment
     ;;
+  check-acp-cortex)
+    check_acp_cortex
+    ;;
   check-fresh-cut-gate)
     # SOURCE cell of the generation-boundary proof: a host whose store the live
     # schema cannot read must be refused BEFORE any write, told the fresh-cut