From 36f3de26faaf6cc9785d605c2307c8de26c9eba0 Mon Sep 17 00:00:00 2001 From: LIghtJUNction Date: Fri, 20 Nov 2026 12:14:05 +0800 Subject: [PATCH 01/12] fix: inspect installed extension with its service identity The Alpine smoke probe reaches a healthy installed service, then fails when the container-root observer reads the other UID's procfs executable link. Run that exact read as the existing service UID and GID with no supplementary groups. Keep the executable-path assertion, timeout, error propagation and subsequent native catalogue checks. --- packaging/linux/extore-plugin-smoke.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/packaging/linux/extore-plugin-smoke.py b/packaging/linux/extore-plugin-smoke.py index 35fc2a06..1695c7c6 100644 --- a/packaging/linux/extore-plugin-smoke.py +++ b/packaging/linux/extore-plugin-smoke.py @@ -104,7 +104,15 @@ def main(): time.sleep(0.1) if not ready: raise RuntimeError("installed extensions did not start without native configuration") - if os.readlink(f"/proc/{process.pid}/exe") != "/usr/bin/lmm-extensions": + # Procfs checks credentials; container root cannot inspect another UID. + identity = subprocess.run( + [sys.executable, "-c", + "import os, sys; print(os.readlink('/proc/' + sys.argv[1] + '/exe'))", + str(process.pid)], + check=True, stdout=subprocess.PIPE, + text=True, timeout=5, user=account.pw_uid, + group=account.pw_gid, extra_groups=[]) + if identity.stdout.strip() != "/usr/bin/lmm-extensions": raise RuntimeError("default process is not the installed program") finally: process.terminate() From 0f556390ebf7586beca614d95dd1f04a7f2e8e57 Mon Sep 17 00:00:00 2001 From: LIghtJUNction Date: Fri, 20 Nov 2026 12:24:11 +0800 Subject: [PATCH 02/12] fix: prepare the existing Identity test prerequisites The Identity workflow invokes all Core targets without the private evidence roots, acquisition fixtures, pinned historical objects or preserved executors required by those tests. Reuse the established Core protocol setup and retain every test assertion. Execute the payment-live case through its mandatory owning runner, which validates the real parent PID and the exact passing test result. Preserve the job timeout, resource configuration, failure propagation and original failed-run evidence. --- .github/workflows/mk-01-identity.yml | 42 ++++++++++++++++++++++++++-- 1 file changed, 40 insertions(+), 2 deletions(-) diff --git a/.github/workflows/mk-01-identity.yml b/.github/workflows/mk-01-identity.yml index e4eaa6c8..3a595d87 100644 --- a/.github/workflows/mk-01-identity.yml +++ b/.github/workflows/mk-01-identity.yml @@ -76,6 +76,17 @@ jobs: if: ${{ !cancelled() && steps.rust.outcome == 'success' }} working-directory: services/core run: cargo clippy --locked --all-targets -- -D warnings 2>&1 | tee "$RUNNER_TEMP/identity-clippy.log" + - name: Build the preserved migration executors + if: ${{ !cancelled() }} + run: | + git fetch --no-tags --depth=1 origin 0510c2455dabcb63e33c719ba52ac189d62612bc 2a0c7bd380f58a553dc903d399255821c1a65d0f 8f1b6b837ace7027f2a62f15168843790ce6de28 + rustup toolchain install 1.99.0 --profile minimal + rustup run 1.99.0 python3 scripts/build-preserved-core.py --family pancake67 --output "$RUNNER_TEMP/preserved-pancake67" + rustup run 1.99.0 python3 scripts/build-preserved-core.py --family early58 --output "$RUNNER_TEMP/preserved-early58" + cat "$RUNNER_TEMP/preserved-pancake67/executor.env" "$RUNNER_TEMP/preserved-early58/executor.env" >> "$GITHUB_ENV" + - name: Prepare private acquisition PostgreSQL fixtures + if: ${{ !cancelled() }} + run: python3 -B scripts/prepare-acquisition-ci.py - name: Test against isolated PostgreSQL databases if: ${{ !cancelled() && steps.rust.outcome == 'success' }} working-directory: services/core @@ -84,8 +95,20 @@ jobs: cargo test --locked --all-targets --no-run LMM_MODEL_PROCESS_CORE_BIN="$(realpath target/debug/lmm-core)" LMM_MODEL_PROCESS_CORE_SHA256="$(sha256sum "$LMM_MODEL_PROCESS_CORE_BIN" | cut -d ' ' -f1)" - LMM_MODEL_PROCESS_ROOT="$(mktemp -d /tmp/lmm-model-XXXXXXXX)" + process_evidence_root="$(mktemp -d "$RUNNER_TEMP/core-process-evidence-XXXXXXXX")" + LMM_MODEL_PROCESS_ROOT="$(mktemp -d "$process_evidence_root/model-XXXXXXXX")" export LMM_MODEL_PROCESS_CORE_BIN LMM_MODEL_PROCESS_CORE_SHA256 LMM_MODEL_PROCESS_ROOT + # Independent TCP/process cases require new private evidence roots. + # Their child-worker config is created by each owning test. + LMM_CONTINUITY_DEV_ARTIFACTS="$(mktemp -d "$process_evidence_root/continuity-dev-XXXXXXXX")" + COMPACT_INDEPENDENT_ARTIFACTS="$(mktemp -d "$process_evidence_root/compact-XXXXXXXX")" + RESPONSES_CONTINUITY_INDEPENDENT_ARTIFACTS="$(mktemp -d "$process_evidence_root/continuity-independent-XXXXXXXX")" + RESPONSES_CONTINUITY_REVIEW_ARTIFACTS="$(mktemp -d "$process_evidence_root/continuity-review-XXXXXXXX")" + LMM_WS_ARTIFACTS="$(mktemp -d "$process_evidence_root/websocket-XXXXXXXX")" + LMM_WS_CORE_BINARY="$LMM_MODEL_PROCESS_CORE_BIN" + export LMM_CONTINUITY_DEV_ARTIFACTS COMPACT_INDEPENDENT_ARTIFACTS + export RESPONSES_CONTINUITY_INDEPENDENT_ARTIFACTS RESPONSES_CONTINUITY_REVIEW_ARTIFACTS + export LMM_WS_ARTIFACTS LMM_WS_CORE_BINARY # The non-ignored payment recovery case requires sealed Core, Go host # and bootstrap binaries. The 302-second case stays ignored. CGO_ENABLED=0 go test -C ../extensions -mod=readonly -c -o "$RUNNER_TEMP/lmm-payment-bootstrap" ./internal/modules/payments @@ -96,7 +119,11 @@ jobs: LMM_PAYMENT_BOOTSTRAP_BIN="$(realpath "$RUNNER_TEMP/lmm-payment-bootstrap")" LMM_PAYMENT_BOOTSTRAP_SHA256="$(sha256sum "$LMM_PAYMENT_BOOTSTRAP_BIN" | cut -d ' ' -f1)" export LMM_PAYMENT_CORE_BIN LMM_PAYMENT_CORE_SHA256 LMM_PAYMENT_GO_BIN LMM_PAYMENT_GO_SHA256 LMM_PAYMENT_BOOTSTRAP_BIN LMM_PAYMENT_BOOTSTRAP_SHA256 - cargo test --locked --all-targets --no-fail-fast 2>&1 | tee "$RUNNER_TEMP/identity-tests.log" + # The owning runner below executes this exact case and checks its real parent PID. + cargo test --locked --all-targets --no-fail-fast -- --skip synthetic_live_proof_crosses_core_go_processes_and_posts_once --nocapture 2>&1 | tee "$RUNNER_TEMP/identity-tests.log" + - name: Synthetic payment live process through owning runner + if: ${{ !cancelled() }} + run: python3 -B scripts/ci-payment-live.py --output "$(realpath -m "$RUNNER_TEMP/payment-live")" 2>&1 | tee "$RUNNER_TEMP/payment-live-build.log" - name: Repeat rejected event acknowledgement regression if: ${{ !cancelled() && steps.rust.outcome == 'success' }} working-directory: services/core @@ -118,5 +145,16 @@ jobs: ${{ runner.temp }}/identity-*.log ${{ runner.temp }}/identity-commit.txt ${{ runner.temp }}/identity-source.tar.gz + ${{ runner.temp }}/preserved-pancake67/provenance.json + ${{ runner.temp }}/preserved-pancake67/source.tar.gz + ${{ runner.temp }}/preserved-pancake67/schema-manifest.json + ${{ runner.temp }}/preserved-pancake67/build.log + ${{ runner.temp }}/preserved-early58/provenance.json + ${{ runner.temp }}/preserved-early58/source.tar.gz + ${{ runner.temp }}/preserved-early58/schema-manifest.json + ${{ runner.temp }}/preserved-early58/build.log + ${{ runner.temp }}/core-process-evidence-* + ${{ runner.temp }}/payment-live-build.log + ${{ runner.temp }}/payment-live/evidence/result.json if-no-files-found: warn retention-days: 7 From 41ed11760917229c3cffe8abe4053cb390bb2d0a Mon Sep 17 00:00:00 2001 From: LIghtJUNction Date: Fri, 20 Nov 2026 13:06:29 +0800 Subject: [PATCH 03/12] ci: return private native evidence to the artifact uploader [skip ci] --- .github/workflows/linux-packages.yml | 32 ++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/.github/workflows/linux-packages.yml b/.github/workflows/linux-packages.yml index 4c00cfbc..b91a8303 100644 --- a/.github/workflows/linux-packages.yml +++ b/.github/workflows/linux-packages.yml @@ -169,6 +169,38 @@ jobs: --arch "$ARCH" --revision "$(git rev-parse HEAD)" \ --parent-netns "$(readlink /proc/self/ns/net)" \ --report /evidence/extore-native-alpine.json 2>&1 | tee out/evidence/extore-native-alpine.log + - name: Return private native evidence to the runner + if: always() + run: | + runner_uid=$(id -u) + runner_gid=$(id -g) + for parent in out out/evidence; do + if [[ -L "$parent" ]]; then + echo "::error::Native evidence parent must not be a symlink: $parent" + exit 1 + fi + if [[ ! -e "$parent" ]]; then exit 0; fi + if [[ ! -d "$parent" || "$(stat -c '%u' -- "$parent")" != "$runner_uid" ]]; then + echo "::error::Expected a runner-owned native evidence directory: $parent" + exit 1 + fi + done + for evidence in \ + out/evidence/extore-native-alpine.consumer.log \ + out/evidence/extore-native-alpine.json \ + out/evidence/extore-native-alpine.json.package.json; do + if [[ -L "$evidence" ]]; then + echo "::error::Native evidence must not be a symlink: $evidence" + exit 1 + fi + if [[ ! -e "$evidence" ]]; then continue; fi + if [[ ! -f "$evidence" ]]; then + echo "::error::Native evidence must be a regular file: $evidence" + exit 1 + fi + sudo chown --no-dereference -- "$runner_uid:$runner_gid" "$evidence" + test -r "$evidence" + done - name: Preserve preview packages and scoped evidence, never publish if: always() uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a From c36656c6e0de8cfa119b396bf78eb2be922cc9a9 Mon Sep 17 00:00:00 2001 From: LIghtJUNction Date: Fri, 20 Nov 2026 13:21:18 +0800 Subject: [PATCH 04/12] test(core): report the actual wrong-system upgrade rejection --- .../upgrade/payment_discounts_tests.rs | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/services/core/src/core_schema/upgrade/payment_discounts_tests.rs b/services/core/src/core_schema/upgrade/payment_discounts_tests.rs index c0439e76..b2751964 100644 --- a/services/core/src/core_schema/upgrade/payment_discounts_tests.rs +++ b/services/core/src/core_schema/upgrade/payment_discounts_tests.rs @@ -404,12 +404,18 @@ async fn app05_upgrade_engine_66_to67_exact_replay_and_runtime_denial(pool: PgPo "1".into() }; engine_offline_boundary(&r).await; - assert!(matches!( - upgrade_database(url.as_str(), wrong_system).await, - Err(UpgradeError::Rejected( - "UPGRADE_DB_SYSTEM_IDENTIFIER_MISMATCH" - )) - )); + let wrong_system_result = upgrade_database(url.as_str(), wrong_system) + .await + .map(|report| report.status); + assert!( + matches!( + &wrong_system_result, + Err(UpgradeError::Rejected( + "UPGRADE_DB_SYSTEM_IDENTIFIER_MISMATCH" + )) + ), + "wrong-system upgrade result: {wrong_system_result:?}" + ); engine_offline_boundary(&r).await; let committed = upgrade_database(url.as_str(), r.clone()).await.unwrap(); From d7562045878baf6054d91606db73d75371ea55df Mon Sep 17 00:00:00 2001 From: LIghtJUNction Date: Fri, 20 Nov 2026 13:26:19 +0800 Subject: [PATCH 05/12] fix(core): acquire the conversation lock before unknown classification --- services/core/src/assistant_model.rs | 15 +-- services/core/tests/assistant_model.rs | 143 +++++++++++++++++++++++++ 2 files changed, 151 insertions(+), 7 deletions(-) diff --git a/services/core/src/assistant_model.rs b/services/core/src/assistant_model.rs index 6686ac6e..eddc4064 100644 --- a/services/core/src/assistant_model.rs +++ b/services/core/src/assistant_model.rs @@ -641,15 +641,16 @@ impl AssistantModel { .await .is_ok(); } - if !settled - && let Ok(mut tx) = service.begin().await - && service + if !settled { + let mut tx = service.begin().await?; + // The deferred exclusion trigger takes this lock at COMMIT. + // Keep the order identical to operation() and finalize(). + lock_conversation_id(&mut tx, &binding.core_conversation_id).await?; + service .charging .unknown_assistant(&mut tx, &request_id, &worker) - .await - .is_ok() - { - let _ = tx.commit().await; + .await?; + tx.commit().await?; } service.operation(&original, &binding).await }); diff --git a/services/core/tests/assistant_model.rs b/services/core/tests/assistant_model.rs index bc96e0f9..8cde25fb 100644 --- a/services/core/tests/assistant_model.rs +++ b/services/core/tests/assistant_model.rs @@ -415,6 +415,149 @@ async fn cancelled_rpc_does_not_cancel_core_worker_or_replay_dispatch(pool: PgPo assert_eq!(p.hits.load(Ordering::SeqCst), 1); } +#[sqlx::test] +async fn unknown_classification_takes_conversation_lock_before_charge_row(pool: PgPool) { + let (_, ledger, session, _, _, account) = fixture(&pool, 100000).await; + let p = Provider::start(true).await; + let s = service(&pool, &p); + let b = binding(&s, &session, "unknown-lock-order", "pause").await; + let caller = { + let s = s.clone(); + let session = session.clone(); + let b = b.clone(); + tokio::spawn(async move { s.reserve_text(&session, &b, "pause").await }) + }; + tokio::time::timeout(Duration::from_secs(2), async { + while p.hits.load(Ordering::SeqCst) == 0 { + tokio::time::sleep(Duration::from_millis(5)).await; + } + }) + .await + .unwrap(); + caller.abort(); + let _ = caller.await; + + let (op, before, held) = tokio::time::timeout(Duration::from_secs(4), async { + let mut poll = pool.begin().await.unwrap(); + for statement in [ + "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE", + "SET LOCAL synchronous_commit=on", + "SET LOCAL lock_timeout='2s'", + "SET LOCAL statement_timeout='5s'", + ] { + sqlx::query(statement).execute(&mut *poll).await.unwrap(); + } + let poll_pid: i32 = sqlx::query_scalar("SELECT pg_backend_pid()") + .fetch_one(&mut *poll) + .await + .unwrap(); + // Own the exact lock operation() takes before touching its charge row. + sqlx::query("SELECT pg_advisory_xact_lock(hashtextextended($1,908534117))") + .bind(&b.core_conversation_id) + .execute(&mut *poll) + .await + .unwrap(); + let (request_id, held): (String, i64) = sqlx::query_as( + "SELECT o.request_id,r.reserved FROM core_assistant.operations o \ + JOIN core_charging.requests r ON r.id=o.request_id \ + WHERE o.grant_id=$1 AND r.state='streaming'", + ) + .bind(&b.delegation_id) + .fetch_one(&mut *poll) + .await + .unwrap(); + let before = ledger.balance(account).await.unwrap(); + assert!(held > 0); + assert_eq!(before.reserved_units, held); + + // The original worker reached this advisory lock at deferred COMMIT, + // after locking r. The corrected worker waits here before locking r. + let worker_pid = loop { + let waiting: Option = sqlx::query_scalar( + "SELECT pid FROM pg_stat_activity \ + WHERE datid=(SELECT oid FROM pg_database WHERE datname=current_database()) \ + AND pid<>$1 AND $1=ANY(pg_blocking_pids(pid))", + ) + .bind(poll_pid) + .fetch_optional(&pool) + .await + .unwrap(); + if let Some(pid) = waiting { + break pid; + } + tokio::time::sleep(Duration::from_millis(5)).await; + }; + + // Take the row locks used by status lookup to close the old request -> + // conversation inversion. Observe both PG wait edges. + let poll_lookup = async move { + let _: String = sqlx::query_scalar( + "SELECT o.request_id FROM core_assistant.operations o \ + JOIN core_assistant.grants g ON g.id=o.grant_id \ + JOIN core_charging.requests r ON r.id=o.request_id \ + WHERE o.request_id=$1 AND r.assistant_grant_id=g.id FOR UPDATE OF o,r", + ) + .bind(&request_id) + .fetch_one(&mut *poll) + .await?; + poll.commit().await + }; + tokio::pin!(poll_lookup); + let mut saw_lock_cycle = false; + let poll_result = loop { + tokio::select! { + result = &mut poll_lookup => break result, + () = tokio::time::sleep(Duration::from_millis(5)) => { + let cycle: bool = sqlx::query_scalar( + "SELECT $1=ANY(pg_blocking_pids($2)) \ + AND $2=ANY(pg_blocking_pids($1))", + ) + .bind(poll_pid) + .bind(worker_pid) + .fetch_one(&pool) + .await + .unwrap(); + saw_lock_cycle |= cycle; + } + } + }; + assert!( + !saw_lock_cycle, + "Unknown classification reversed the conversation/request lock order" + ); + poll_result.unwrap(); + loop { + let op = s.operation(&session, &b).await.unwrap(); + if op.state == State::Unknown { + break (op, before, held); + } + tokio::time::sleep(Duration::from_millis(20)).await; + } + }) + .await + .unwrap(); + + assert!(op.answer_text.is_none()); + assert!(op.settled_credits.is_none()); + assert_eq!(op.reserved_credits, held); + let after = ledger.balance(account).await.unwrap(); + assert_eq!( + (after.available_units, after.reserved_units), + (before.available_units, before.reserved_units) + ); + let durable: (String, i64, i64) = + sqlx::query_as("SELECT state,reserved,settled FROM core_charging.requests WHERE id=$1") + .bind(&op.request_id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(durable, ("reconcile".into(), held, 0)); + let replay = s.reserve_text(&session, &b, "pause").await.unwrap(); + assert_eq!(replay.state, State::Unknown); + assert_eq!(replay.request_id, op.request_id); + assert_eq!(p.hits.load(Ordering::SeqCst), 1); +} + #[cfg(unix)] #[sqlx::test] async fn rpc_requires_single_host_protocol_and_original_personal_session(pool: PgPool) { From 5756a5e442a4416174fd25a64cad6db26bb38ea3 Mon Sep 17 00:00:00 2001 From: LIghtJUNction Date: Fri, 20 Nov 2026 14:15:04 +0800 Subject: [PATCH 06/12] test(store): sync native loader dependency in isolated pgtest module --- services/extensions/internal/modules/store/pgtest/go.mod | 1 + services/extensions/internal/modules/store/pgtest/go.sum | 2 ++ 2 files changed, 3 insertions(+) diff --git a/services/extensions/internal/modules/store/pgtest/go.mod b/services/extensions/internal/modules/store/pgtest/go.mod index ceb1c26d..dcfa560a 100644 --- a/services/extensions/internal/modules/store/pgtest/go.mod +++ b/services/extensions/internal/modules/store/pgtest/go.mod @@ -9,6 +9,7 @@ require ( require ( github.com/BurntSushi/toml v1.6.0 // indirect + github.com/ebitengine/purego v0.11.3 // indirect golang.org/x/crypto v0.59.0 // indirect ) diff --git a/services/extensions/internal/modules/store/pgtest/go.sum b/services/extensions/internal/modules/store/pgtest/go.sum index 102dcaca..69a39b90 100644 --- a/services/extensions/internal/modules/store/pgtest/go.sum +++ b/services/extensions/internal/modules/store/pgtest/go.sum @@ -1,5 +1,7 @@ github.com/BurntSushi/toml v1.6.0 h1:dRaEfpa2VI55EwlIW72hMRHdWouJeRF7TPYhI+AUQjk= github.com/BurntSushi/toml v1.6.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= +github.com/ebitengine/purego v0.11.3 h1:OB+JLpdm7ioymhyA+6s5kbb/uOuYycAgL8NNTFc5MLg= +github.com/ebitengine/purego v0.11.3/go.mod h1:DCHPP08djqhNSoTfImcnHYQRZmd0qhakvrozqaEYhGQ= github.com/lib/pq v1.12.3 h1:tTWxr2YLKwIvK90ZXEw8GP7UFHtcbTtty8zsI+YjrfQ= github.com/lib/pq v1.12.3/go.mod h1:/p+8NSbOcwzAEI7wiMXFlgydTwcgTr3OSKMsD2BitpA= golang.org/x/crypto v0.59.0 h1:xS2jhqYbzNrpvkWP2YTDf4TJwBy3ykR03i8vFDxEc7c= From d1e5579009276442e2d129357a9e2a035a83043f Mon Sep 17 00:00:00 2001 From: LIghtJUNction Date: Fri, 20 Nov 2026 14:15:08 +0800 Subject: [PATCH 07/12] test(core): expose unexpected managed70 rollback result --- .../upgrade/managed_applications_tests.rs | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/services/core/src/core_schema/upgrade/managed_applications_tests.rs b/services/core/src/core_schema/upgrade/managed_applications_tests.rs index e1bfae16..88078294 100644 --- a/services/core/src/core_schema/upgrade/managed_applications_tests.rs +++ b/services/core/src/core_schema/upgrade/managed_applications_tests.rs @@ -330,13 +330,17 @@ async fn managed70_owner_upgrade_preserves_all_other_data_acl_and_commit_recover engine_offline_boundary(&request).await; let rollback = FAIL_AFTER_OAUTH_CAS .scope(true, upgrade_database(url.as_str(), request.clone())) - .await; - assert!(matches!( - rollback, - Err(UpgradeError::Rejected( - "MANAGED_APPLICATIONS_INJECTED_AFTER_OAUTH_CAS" - )) - )); + .await + .map(|report| report.status); + assert!( + matches!( + &rollback, + Err(UpgradeError::Rejected( + "MANAGED_APPLICATIONS_INJECTED_AFTER_OAUTH_CAS" + )) + ), + "managed70 injected rollback result: {rollback:?}" + ); let mut inspect = PgConnection::connect_with(&options).await.unwrap(); assert_eq!( snapshot_data(&mut inspect, &tables, &sequences) From f9b7a5d0230fdaeb7c1f651b6443083a1ff04c8d Mon Sep 17 00:00:00 2001 From: LIghtJUNction Date: Fri, 20 Nov 2026 14:27:47 +0800 Subject: [PATCH 08/12] test(rpc): include pinned Extore sources in frozen image inputs --- .github/workflows/core-protocol.yml | 4 ++++ scripts/test-core-rpc-docker.py | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/.github/workflows/core-protocol.yml b/.github/workflows/core-protocol.yml index a27eb640..879f1502 100644 --- a/.github/workflows/core-protocol.yml +++ b/.github/workflows/core-protocol.yml @@ -42,6 +42,10 @@ jobs: persist-credentials: false - name: Initialize the pinned CLI only for archive contract checks run: git submodule update --init --depth 1 -- apps/cli + - name: Initialize the pinned Extore native plugin for formal images + run: | + git submodule update --init --depth 1 -- packages/extore + python3 -B scripts/check-extore-plugin-pin.py - name: Record exact integration source run: | git rev-parse HEAD > "$RUNNER_TEMP/core-source-sha.txt" diff --git a/scripts/test-core-rpc-docker.py b/scripts/test-core-rpc-docker.py index 6c7b7294..7eb5abff 100644 --- a/scripts/test-core-rpc-docker.py +++ b/scripts/test-core-rpc-docker.py @@ -310,6 +310,7 @@ def source_inputs(): "services/core/schema", "contracts/proto", "services/extensions", + "packages/extore/plugins/commerce", "deployment/docker", "deployment/postgres", "config/legal/templates", @@ -321,6 +322,9 @@ def source_inputs(): "LICENSE", "NOTICE", "THIRD-PARTY-LICENSES.md", + "packaging/extore-plugin.json", + "packages/extore/LICENSE", + "packages/extore/plugins/commerce/THIRD_PARTY.md", "services/core/Cargo.toml", "services/core/Cargo.lock", "services/core/build.rs", From b896605e9abc2b2e3f4e9e48d9dda5ac978d29dc Mon Sep 17 00:00:00 2001 From: LIghtJUNction Date: Fri, 20 Nov 2026 14:46:22 +0800 Subject: [PATCH 09/12] test(ci): match Core protocol's required Extore submodule [skip ci] --- scripts/workflow-topology.test.mjs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/workflow-topology.test.mjs b/scripts/workflow-topology.test.mjs index 8ae95281..6332a6d7 100644 --- a/scripts/workflow-topology.test.mjs +++ b/scripts/workflow-topology.test.mjs @@ -83,7 +83,7 @@ test('workflows initialize only their required pinned submodules', () => { lmm: ['apps/cli'], 'microservice-distribution': ['apps/cli', 'apps/cli', 'packages/extore'], 'linux-packages': ['apps/cli', 'packages/extore'], - 'core-protocol': ['apps/cli'], + 'core-protocol': ['apps/cli', 'packages/extore'], deploy: ['packages/extore'], }; for (const [name, paths] of Object.entries(dependencies)) { From 504ffe42aa3ffbf6d1a2629b56372de4297915a8 Mon Sep 17 00:00:00 2001 From: LIghtJUNction Date: Fri, 20 Nov 2026 17:16:24 +0800 Subject: [PATCH 10/12] test: await root observation before restart snapshot --- .../core/src/model_http/responses_continuity_independent.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/services/core/src/model_http/responses_continuity_independent.rs b/services/core/src/model_http/responses_continuity_independent.rs index 185c934d..3b73178b 100644 --- a/services/core/src/model_http/responses_continuity_independent.rs +++ b/services/core/src/model_http/responses_continuity_independent.rs @@ -1018,6 +1018,8 @@ async fn responses_continuity_independent_actual_kill_restart_same_database(pool json_reply(call(&core, &lab.fixture.key, "independent-restart-root", &body).await) .await; assert_active(lab, &id, &root).await; + // The successful HTTP body can precede its performance observation. + native_http::test_support::performance_sample(&lab.fixture.pool, &id).await; let before = snapshot(&lab.fixture.pool).await; let old_pid = core.child.id(); core.child.kill().unwrap(); From 1a260a5473fb0c5c8ec9f5872a433012eecb25fb Mon Sep 17 00:00:00 2001 From: LIghtJUNction Date: Fri, 20 Nov 2026 19:06:40 +0800 Subject: [PATCH 11/12] test: await successful request telemetry before refusal snapshots The original full Identity run observed a global usage-count change from32 to33 in the store-tristate refusal test. Each earlier successful response can finish before its detached performance write completes. Wait for the existing bounded, request-specific performance sample after each successful stored request and before taking later refusal baselines. Keep every original snapshot, balance, provider-call, and refusal assertion unchanged. The historical extra event's identity remains unknown; its original failure evidence is retained. [skip ci] --- .../core/src/model_http/responses_continuity_independent.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/services/core/src/model_http/responses_continuity_independent.rs b/services/core/src/model_http/responses_continuity_independent.rs index 3b73178b..8135b47b 100644 --- a/services/core/src/model_http/responses_continuity_independent.rs +++ b/services/core/src/model_http/responses_continuity_independent.rs @@ -1339,6 +1339,8 @@ async fn responses_continuity_independent_store_tristate_and_exact_refusal(pool: let label=format!("independent-store-{default}-{explicit:?}"); let (id,result,bytes)=json_reply(call(&core,&lab.fixture.key,&label,&body).await).await; assert_packets(&lab.fixture.pool,&id,&[&bytes]).await; + // Complete each successful observation before a global refusal snapshot. + native_http::test_support::performance_sample(&lab.fixture.pool,&id).await; let last=lab.s().seen().last().unwrap().clone(); assert_eq!(last.get("store"),body.get("store"),"wire must preserve omission/false/true"); if explicit.unwrap_or(default) {assert_active(lab,&id,&result).await;} From fe7f2916d9a0d7c01829163a2bbd4745848a0463 Mon Sep 17 00:00:00 2001 From: ChatGPT Date: Fri, 20 Nov 2026 17:23:01 +0000 Subject: [PATCH 12/12] Archive generated review media and ignore future local artifacts [skip ci] --- .gitignore | 3 +++ docs/generated-review-artifacts.md | 5 +++++ 2 files changed, 8 insertions(+) create mode 100644 docs/generated-review-artifacts.md diff --git a/.gitignore b/.gitignore index 7ba30948..a4a075c3 100644 --- a/.gitignore +++ b/.gitignore @@ -84,3 +84,6 @@ __pycache__/ # Scratch test outputs and untracked indices /scripts/.key-rights-test-output/ /undefined/ + +# Generated review media is archived outside Git. +/apps/web/.whitespace-review/ diff --git a/docs/generated-review-artifacts.md b/docs/generated-review-artifacts.md new file mode 100644 index 00000000..f368f046 --- /dev/null +++ b/docs/generated-review-artifacts.md @@ -0,0 +1,5 @@ +# 界面审阅截图 + +`apps/web/.whitespace-review/` 是本地生成目录,已加入 Git 忽略清单。 + +[2026-11-20 截图归档](https://drive.google.com/file/d/1w482i4fJPcmkwqB5KsypfyFwA-TNosFF/view?usp=drivesdk)保留历史中的 12 个 PNG 版本。归档内的 `manifest.json` 记录原始路径、Git 对象哈希、SHA-256 和备份时的分支与标签。