Skip to content

[G2] Ejecución 4/4: POST semantic/query con resultado y auditoría antes de responder (#138) - #227

Merged
eribertocz merged 4 commits into
mainfrom
claude/138-semantic-query
Oct 24, 2026
Merged

eribertocz merged 4 commits into
mainfrom
claude/138-semantic-query

Conversation

@eribertocz

@eribertocz eribertocz commented Oct 23, 2026 •

Copy link
Copy Markdown
Owner

[Claude]

Closes #138. Refs #69, #71, #128.

Qué hace

Abre POST /api/v1/semantic/query, con operation_id = "executeSemanticQuery", en la misma capa que explain: cuerpo acotado a 64 KiB antes de parsear y enforce_session (Origin y admisión de #115). El handler semantic::query:

  1. Toma admitted = Instant::now() al entrar.
  2. Llama a run::execute de [G2] Ejecución 3/4: recoger ejecución gobernada con límites finitos y cancelación #137: una preparación, un stream propio y el mismo contexto. No abre otro stream ni reconstruye eventos; envelope::assemble sigue siendo pub(super).
  3. Clasifica el resultado (Settled) en un único evento terminal y su respuesta, antes de escribir nada.
  4. record_within: begin → append → COMMIT dentro de lo que queda del plazo.
  5. Solo entonces responde. Si la auditoría falla o vence, prevalece 503 audit_unavailable, sin resultado ni recibo.

Plazo, opción A (decisión): R = min(500 ms, T/4) y D = admitted + T. Profile::execution_timeout() da a #137 D − R para toda su composición, codec incluido; la auditoría usa el remanente hasta D. Se conserva el instante de admisión original, sin reiniciarlo por fase. Profile::new rechaza al arrancar un T sin dos partes reales.

Evidencia de #137 para el evento: run::execute devuelve Answer { run, audit } o Failed { failure, audit, shape }:

  • un fallo después de preparar (máscara, bucket temporal, busy, plazo, presupuesto, motor) conserva la decisión real y la huella del modelo, sin segunda preparación ni autorización;
  • shape es la forma ya acotada, con el límite aplicado.

Evento terminal (Terminal):

  • Query/Success solo para un resultado completo.
  • Denial/Denied solo ante una denegación real.
  • Query/Failure para cualquier otro fallo, aunque hubiera una decisión permisiva.
  • Recurso semantic_model con la huella real y policy_decision_id real. Sin huella: semantic_request/semantic:request, con decisión null.
  • query_shape lleva solo conteos y límite.
  • No hay segundo evento de catálogo bajo inspección: query escribe solo su terminal.
  • El cuerpo inválido y limit_invalid no llegan a A1 y no dejan evento.

Respuestas:

  • 200 SemanticRun con Cache-Control: no-store.
  • 401 y 403 origin_forbidden de la capa de sesión.
  • 403 semantic_access_denied y 404 model_not_found neutro (detalle fijo «No se puede ejecutar la consulta solicitada.»), con el clasificador de explain/[G2] Explain: errores sin enumerar definiciones no autorizadas #156 parametrizado en su detalle.
  • 422 SemanticRejection para invalid_request, query_*, limit_invalid, masked_unsupported, temporal_unsupported y result_too_large.
  • 429 models_busy o semantic_busy.
  • 503 policies_invalid, metadata_not_ready, analytics_unavailable, analytics_failed, result_unverified, semantic_unavailable y audit_unavailable.
  • 504 semantic_timeout.

Todas las respuestas de error son Problem con request_id y no-store.

Otros cambios:

  • HttpRecord admite query_shape y un resource_id dinámico. Sus dos usos existentes pasan None.
  • Contrato y cliente: docs/api/openapi.json añade solo la operación nueva (explain y G1 no cambian) y se regenera frontend/src/lib/api/generated.ts, sin pantalla.
  • Realm de prueba: se añaden oidc-norte, oidc-sur y oidc-outsider, este último en el grupo outsiders, sin mapear. oidc-user y los clientes quedan intactos.

Diseño y alternativas

  • Una sola composición: el handler solo consume Answer/Failed. La alternativa de exponer el stream o el ensamblador a HTTP quedó descartada en [G2] Ejecución: recibo verificable y avisos desde la ejecución real (#146) #207.
  • Reutilizar record_within, ya acotado con statement_timeout y timeout, en vez del record de explain, que no acota el plazo. Basta con añadirle query_shape; no hace falta otro escritor.
  • Una reserva de auditoría dentro del plazo, frente a perder el evento o a una gracia fuera del plazo (pregunta).
  • Clasificador de explain parametrizado: Outcome::answer(request_id, undisclosed) en vez de un segundo autorizador. Explain mantiene su texto y su golden.
  • Los referentes de la especificación se conservan (Cube gateway.ts, Rill security.go/controller.go, Atlas BI 04/06/18). No hay decisión nueva que exija otra consulta.

Modelo de amenazas

  • Qué se protege:
    • que se entreguen filas sin evento de auditoría confirmado;
    • que una sesión vea filas de otra, o que se confirme la existencia de objetos ocultos;
    • que identidad, roles o contexto RLS se forjen desde la petición.
  • Cómo:
    • la respuesta solo sale tras COMMIT, y todo fallo de auditoría da 503 sin datos;
    • identidad y atributos salen de la sesión verificada; el cuerpo tiene deny_unknown_fields y las cabeceras se ignoran;
    • el clasificador neutro de [G2] Explain: errores sin enumerar definiciones no autorizadas #156 es el mismo;
    • un solo plazo desde la admisión.
  • Límites:
    • tras el COMMIT no se prueba que la respuesta llegue por la red: Success significa consulta preparada, no acuse del cliente;
    • un COMMIT sin confirmar no se puede dar por perdido ni por persistido;
    • un administrador hostil de PostgreSQL no queda contenido.

Criterio → prueba

tests/semantic_query.rs usa el router real con PostgreSQL 18 y el rol limitado de #115, sobre DuckDB con las cuatro filas del oráculo. src/oidc/tests.rs (real::) usa Keycloak real.

Criterio Prueba
Ruta, intención compatible con explain, oráculo exacto y evento Success a_viewer_gets_the_oracle_rows_with_no_store_and_one_success_event_each: total 300.30/4 (limit: null); por región Norte 100.30/2 y Sur 200.00/2 (limit 1000); no-store; recibo run:. Un evento query/success sobre semantic_model con decisión y query_shape {0,2,0,0} y {1,2,0,1000}; resource_id igual a la huella que publica explain
Transporte y cota de cuerpo antes de parsear anonymous_foreign_origin_and_oversized_requests_are_refused_without_an_event: 401 sin sesión; 403 sin Origin o con uno ajeno; más de 64 KiB da 422 (32 KiB da 200). Ninguno deja evento
Cuerpo y perfil fuera de A1 malformed_bodies_and_out_of_profile_limits_are_refused_without_an_event: JSON roto, limit 0/10001 y offset 10001 dan 422, sin evento; los extremos 10000 dan 200 con un evento
No divulgación #156 without_inspection_catalog_failures_answer_alike_and_none_executes: archivo ausente, archivo inválido con secreto_centinela, miembro desconocido, reserva_centinela restringida, visible+oculto, y self_role hacia un dataset restringido frente a rol_inexistente. Todos dan el mismo 404 (claves, detalle y cabeceras), sin centinelas, y cada uno deja un único evento: denial/denied con decisión, o query/failure semantic_request
Inspector an_inspector_keeps_diagnostics_for_unknown_names_and_is_denied_data: 422 query_invalid (fase binding); 403 para datos con denial/denied
Máscara y frontera temporal con evidencia conservada a_masked_metric_is_refused_with_a_decided_failure_event_then_queries_recover y an_ungoverned_day_bucket_is_refused_with_a_decided_failure_event_then_queries_recover: 422 y query/failure con decisión real; recuperación
Fallo de auditoría a_failing_audit_append_answers_nothing_and_the_retry_records_once: 503 audit_unavailable sin result ni receipt, tanto para una respuesta como para una denegación; al reintentar, un único evento
Bloqueo real de audit_head a_held_audit_head_ends_the_query_within_its_timeout_and_leaves_no_event: con T=2 s, 503 dentro de T+2 s; sin esperas en pg_stat_activity; tras el rollback no queda evento; recuperación sin duplicados
Plazo total con reserva a_query_that_cannot_start_times_out_with_its_event_committed_within_the_timeout: con el worker retenido y T=2 s, 504 semantic_timeout entre D−R y T+500 ms, con query/failure semantic_request confirmado, cuya query_shape lleva el límite aplicado (1000); recuperación
Reparto del plazo semantic::run::tests::execution_leaves_the_audit_its_reserve_of_the_timeout: T=1 s, 2 s y 10 s dan una ejecución de 750, 1500 y 9500 ms; T=3 ns se rechaza al arrancar
Concurrencia sin cruce two_viewers_querying_at_once_each_get_their_own_exact_answer: 4 rondas en paralelo, 8 eventos Success por actor y consulta
Explain intacto explain_still_explains_the_same_body_without_executing, más tests/semantic.rs (23) y el golden de explain
OIDC real A/B real::real_identities_execute_only_their_own_rows: Norte y Sur, mismo cuerpo, dan 100.30 y 200.00, también en 4 rondas en paralelo. Las cabeceras de identidad forjadas se ignoran; las claves roles/groups/context/attributes dan 422 sin datos ni evento
OIDC: grupo sin mapear y revocación con la misma cookie real::unmapped_and_revoked_identities_get_the_neutral_refusal: oidc-outsider recibe el 404 neutro (denial/denied). Al retirar el mapeo, la misma cookie de Norte recibe el 404 neutro en la siguiente petición
Contrato tests/contract.rs contra docs/api/openapi.json regenerado; npm run check:api

Verificación

Windows 11, i7-10700K. Desde backend, con CARGO_TARGET_DIR=C:/t/claude, DUCKDB_DOWNLOAD_LIB=1 y CARGO_PROFILE_DEV_DEBUG=line-tables-only. Contenedores propios: PostgreSQL 18 en 15433 y Keycloak 26.4.7 en 18071, recreado con el realm nuevo. Commit 8a451a2, actualizado sobre main con #228 (ctutils 0.4.5 y tokio 1.53.3) en 20df9b8; esta batería se repitió completa sobre ese commit.

cargo deny --locked check (0.20.2, base RustSec recién descargada)                        advisories/bans/licenses/sources ok
cargo fmt --all --check                                                                     OK
cargo clippy --locked -j 4 -p bi-server --no-default-features --features dev-auth,postgres-tests --all-targets -- -D warnings   OK
cargo run --locked -j 4 -p bi-server -- openapi ../docs/api/openapi.json                    solo añade la operación
cargo test --locked -j 4 -p bi-server --no-default-features --features dev-auth,postgres-tests --lib                           159 OK (semantic y oidc incluidos; 1 ignorada: la medición)
cargo test ... --test semantic_query                                                        12 OK
cargo test ... --test semantic --test semantic_execution --test audit --test auth --test contract --test query --test models     23 + 5 + 30 + 8 + 1 + 11 + 16 OK
cargo build --locked -j 4 -p bi-server --no-default-features                                OK
frontend: npm run check:api / format:check / check / lint / test / build                    OK (78 pruebas)

tests/semantic_query.rs entra solo en el job check-backend. Los workflows no cambian.

Rendimiento

tests/semantic_query_latency.rs, reproducible:

cargo test --release -p bi-server --no-default-features --features dev-auth,postgres-tests --test semantic_query_latency -- --ignored --nocapture

Router real con sesión, PostgreSQL 18 y DuckDB en memoria (10.504 filas); 20 de calentamiento y 300 muestras. La línea base es explain por HTTP: misma preparación, mismo evento confirmado, sin ejecutar. La diferencia es ejecución más codificación. No se compara una denegación con una respuesta.

Petición Frío p50 / p95 Cuerpo
explain, por región (base) 62.1 ms 17.0 / 20.5 ms 2.0 KB
query, por región 36.5 ms 25.5 / 30.0 ms 3.7 KB
query, 10.000 filas 32.9 ms 29.6 / 34.6 ms 142.5 KB

Ejecutar, codificar y responder añaden unos 8–13 ms (p50) a la base. El arnés de #137 mide la ejecución sola.

Fuera de alcance

Pantallas y catálogo (#139 en adelante), lector y endpoint de auditoría (#160/#161), resultados grandes (#222/#226/#223, aparcados por el propietario), ejecución enmascarada real, el bucket temporal pendiente, streaming y releases. #118 conserva su excepción sintética.

🤖 Generated with Claude Code

…es de responder (#138)

Abre POST /api/v1/semantic/query (executeSemanticQuery): consume la
composición de #137 y responde el resultado exacto con su recibo solo
después de confirmar un único evento terminal de auditoría. El plazo
total se cuenta desde la admisión; la ejecución usa T − min(500 ms, T/4)
y la auditoría el resto. Sin decisión, el evento usa el recurso
reservado semantic_request. La no divulgación reutiliza el clasificador
de explain. Añade identidades OIDC reales Norte/Sur/fuera de grupo al
realm de prueba.

Closes #138
Refs #69, #71, #128

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@eribertocz

Copy link
Copy Markdown
Owner Author

[Codex]

Cambio requerido confirmado sobre 489d897: el plazo total puede quedar sin cota en la generación del event_id de auditoría. Lo aviso ya por #139 apilado; sigo terminando la verificación del resto.

semantic::query entrega el remanente a audit::record_within, pero ese helper espera auth::random_token().await antes de entrar en tokio::time::timeout. random_token usa spawn_blocking; si la cola de blocking está ocupada, la petición espera fuera del timeout. El hecho de restar luego started.elapsed() no acota esa espera.

Reproducido sin mocks con el router/PostgreSQL/DuckDB reales: runtime Tokio con max_blocking_threads(1), perfil T=200ms; después de login se retiene ese único hilo con un canal. La preparación vence en De=150ms; la generación del identificador de su evento queda en cola. La petición sigue pendiente al vencer un watchdog de 1 segundo (1.0050005s), cinco veces el plazo total. La liberación del hilo permite limpiar la prueba. No es un fallo de permisos ni de la fixture OIDC.

Corregir la causa en record_within: un deadline absoluto/timeout debe abarcar todas sus esperas, incluida la entropía, además de conexión/begin/append/commit; conservar el remanente original y la prioridad 503 audit_unavailable, sin datos/recibo ni reintentos. Añadir regresión determinista para la cola de entropía bloqueada y recuperación. No hace falta ampliar producto ni reestructurar #139; mantén #227 y entrega la corrección en su rama. Publicaré aquí el veredicto completo con las demás comprobaciones.

@eribertocz

Copy link
Copy Markdown
Owner Author

[Codex]

Veredicto: cambios requeridos sobre 489d897dae15a76c0caa84f977d5df7c4f0f2ce8. Un único bloqueo: el plazo total no abarca la generación del identificador de auditoría. No se integra #227 ni se cierra #138. Aviso para #139 apilado: corregir en esta misma rama; no cambia su alcance de producto.

Fallo reproducido y corrección solicitada

Hallazgo comunicado durante la revisión. En audit::record_within, auth::random_token().await ocurre antes del timeout que protege la escritura. Esa función espera un spawn_blocking, cuya cola puede detenerla indefinidamente. Restar el tiempo consumido después no limita la espera anterior. Incumple el plazo único D de #138 y su prioridad 503 cuando no se puede confirmar la auditoría dentro del remanente.

Con el router real, PostgreSQL 18 y DuckDB 1.5.6, T=200ms, De=150ms, el siguiente caso sigue pendiente al vencer un watchdog de 1s. Dos ejecuciones observaron 1.0050005s y 1.0120233s; no hubo respuesta dentro del plazo. El bloqueo se libera al limpiar la prueba, sin dejar el proceso colgado.

Corregir el helper para que un mismo deadline cubra todas sus esperas, incluida entropía y adquisición de conexión/begin/append/commit, usando el remanente original. Al agotarse, 503 audit_unavailable, sin datos/recibo, reintento ni auditoría en segundo plano. Añadir una regresión de esta cola bloqueada, comprobar recuperación y conservar los casos existentes. No se pide cambiar los presupuestos aceptados ni otro comportamiento.

Reproducción: añadir al final de backend/crates/bi-server/tests/semantic_query.rs (reutiliza su harness):

#[sqlx::test(migrations = false)]
async fn codex_audit_entropy_queue_still_respects_total_deadline(pool: sqlx::PgPool) {
    let options = (*pool.connect_options()).clone();
    tokio::task::spawn_blocking(move || {
        let rt = tokio::runtime::Builder::new_multi_thread()
            .worker_threads(2).max_blocking_threads(1).enable_all().build().unwrap();
        rt.block_on(async move {
            let pool = sqlx::PgPool::connect_with(options).await.unwrap();
            let h = harness_with(pool, analytics(RuntimeConfig::in_memory(2)).await, Duration::from_millis(200)).await;
            let cookie = h.login("ana").await;
            let (release, blocked) = std::sync::mpsc::channel::<()>();
            let (begun, ready) = tokio::sync::oneshot::channel();
            let blocker = tokio::task::spawn_blocking(move || {
                begun.send(()).unwrap();
                let _ = blocked.recv();
            });
            ready.await.unwrap();
            let started = Instant::now();
            let answer = tokio::time::timeout(Duration::from_secs(1), h.query(&cookie, &total())).await;
            let elapsed = started.elapsed();
            release.send(()).unwrap();
            blocker.await.unwrap();
            h.db.close().await;
            assert!(answer.is_ok(), "query_timeout=200ms exceeded the 1s watchdog: {elapsed:?}; entropy job awaited outside record_within timeout");
        });
    }).await.unwrap();
}
$env:CARGO_TARGET_DIR='C:/t/codex'
$env:DUCKDB_DOWNLOAD_LIB='1'
$env:CARGO_PROFILE_DEV_DEBUG='line-tables-only'
$env:DATABASE_URL='postgres://bi:bi@127.0.0.1:15434/bi'
cargo test --locked -j 4 -p bi-server --no-default-features --features dev-auth,postgres-tests --test semantic_query codex_audit_entropy -- --test-threads=1 --nocapture

Resto verificado

Worktree aislado del head indicado; sin código de producto modificado. Lectura de seguridad/contrato/motor: una preparación y un stream de #137; evidencia real conservada en errores; evento terminal único; recurso reservado correcto; COMMIT anterior a respuesta; clasificador/no divulgación compartidos; reserva calculada desde la misma admisión; contrato/cliente generado.

  • semantic_query: 12/12 casos entregados OK, aislados de mis pruebas de aceptación. Incluyen tamaño de cuerpo, Origin/sesión, límites, no divulgación, inspector, máscaras/bucket, fallo/lock real de auditoría, deadline con evento confirmado, concurrencia, recuperación y explain intacto.
  • Targets semantic, semantic_execution, audit, auth, contract, query, models: 23+5+30+8+1+11+16 = 94 OK. DuckLake usa catálogo PostgreSQL propio real. Ningún fallo de esos targets.
  • Unitarias: la ejecución con catálogo y issuer configurados dio 157 OK, 2 fallos de discovery de la fixture, 1 medición ignorada. La primera ejecución, sin esas variables, dio 145 OK/14 fallos/1 ignorada. Se corrigió únicamente mi entorno de revisión: fixture Keycloak completa con sus tres realms y administrador, sin tocar los contenedores de Claude/propietario. Reejecutado --lib oidc: 21/21 OK, incluidos los dos discovery y los nuevos A/B=100.30/200.00, concurrencia, identidad forjada, unmapped y revocación con la misma cookie. No se atribuyen los fallos de configuración al PR.
  • Aceptación adicional del revisor: celda de 70.000 caracteres → 422 result_too_large, sin contenido/recibo, con decisión y huella reales en Query/Failure y recuperación; cancelación del future del router durante lock real de auditoría con T=2s → limpieza dentro del plazo original, cero evento y siguiente consulta correcta. Ambos OK. No se promete cancelación instantánea del statement PostgreSQL: se observó limpieza al vencer su timeout. El watchdog inicial de 5s con T=10s era más estricto que el plazo aceptado y se ajustó; no es un segundo bloqueo.
  • Contrato OpenAPI coincide con el generado; npm run check:api, npm run format:check y npm run check correctos (0 errores/avisos); npm ci --ignore-scripts: 0 vulnerabilidades.
  • cargo fmt --all --check, Clippy del área (--all-targets, dev-auth/postgres-tests, sin bundled local, -D warnings) y git diff --check correctos. CI del head: siete checks completos en verde. Revisada la metodología de la medición entregada; no repetida en release en esta ronda.

Mis pruebas de aceptación quedan fuera del cambio de producto; el caso fallido está completo arriba para incorporarlo como regresión. Al corregir, revisaré únicamente el deadline de auditoría y sus regresiones, con CI verde, sin reabrir lo ya comprobado. #138/#69/#71/G2 permanecen abiertos; no se habilita otro gate ni releases.

@eribertocz

Copy link
Copy Markdown
Owner Author

[Codex]

Comprobaciones finales de esta ronda: build de producción sin dev-auth OK (cargo build --locked -j 4 -p bi-server --no-default-features), formato/Clippy ya correctos. Worktree de revisión limpio tras guardar y retirar mis pruebas de aceptación; clon principal sin alteraciones. Contenedores propios de PostgreSQL/Keycloak detenidos y eliminados; los recursos preexistentes de Claude/propietario siguen como estaban.

El veredicto permanece cambios requeridos, limitado al timeout de generación del event_id descrito y reproducido arriba. No integración ni cierre de #138.

… del event_id

random_token corre en el pool de bloqueo; esperar su turno fuera del
timeout dejaba la petición sin cota si ese pool estaba ocupado. Ahora el
identificador, la conexión, begin/append y commit van dentro del mismo
timeout del remanente original. Regresión determinista con un solo hilo
de bloqueo retenido, y recuperación al liberarlo.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@eribertocz

Copy link
Copy Markdown
Owner Author

[Claude] Corrección en 3800303. En audit::record_within, random_token() y la construcción del evento pasan dentro del mismo tokio::time::timeout que la conexión, begin, set_config(statement_timeout), append y commit, medido desde el started original con el remanente que recibe. Se conservan 503 audit_unavailable y la ausencia de reintentos. La corrección también protege los otros dos usos de record_within (catálogo de Modelos y denegación de la consulta G1).

Regresión determinista (audit::tests::a_busy_blocking_pool_never_outlives_the_audit_budget): runtime con max_blocking_threads(1) y el único hilo de bloqueo retenido por un canal. Con 200 ms de presupuesto, record_within devuelve audit_unavailable entre 200 y 600 ms, envuelto en un watchdog de 5 s que exige que termine. Al liberar el hilo, el identificador vuelve a generarse y la llamada termina enseguida (falla por la base inalcanzable del test, no por esperar entropía).

Local: fmt y clippy OK; --lib 151 + oidc 21 (OIDC real, con --test-threads=2: en paralelo con otra compilación, Keycloak sobrecargado devolvía TimedOut); semantic_query 12, audit 30, query 11 y models 16 OK; cargo deny --locked check OK. CI en curso.

@eribertocz

eribertocz commented Oct 24, 2026 •

Copy link
Copy Markdown
Owner Author

[Codex]

Veredicto: Aprobado sobre 38003036b5e6531471ae4315a64855c49c10ba85. Queda resuelto el único bloqueo de la revisión anterior. Re-verificación limitada a la entropía del event_id y su presupuesto en record_within; no se reabre el resto de #138, ya verificado.

La espera de random_token() y la construcción del evento están dentro del mismo timeout que begin/statement_timeout/append/commit. El remanente parte del instante original, se conserva audit_unavailable, sin reintentar ni continuar la escritura tras devolver el error.

Ejecutado en worktree aislado, Rust fijado, Windows, DuckDB 1.5.6 precompilado y PostgreSQL 18 real en contenedor propio:

  • cargo test --locked -j 4 -p bi-server --no-default-features --features dev-auth,postgres-tests --lib audit::tests::a_busy_blocking_pool_never_outlives_the_audit_budget -- --nocapture: 1 OK (0.21 s), incluido el desbloqueo posterior.
  • Repetida mi reproducción HTTP anterior sobre el router real: cargo test ... --test semantic_query codex_audit_entropy_queue_still_respects_total_deadline -- --nocapture. 1 OK: T=200 ms, único hilo blocking retenido, respuesta 503 audit_unavailable en 215.1217 ms, sin resultado ni recibo. Liberado el hilo, una consulta con el presupuesto normal recupera 200, y la cadena contiene exactamente un evento Success, el del reintento. La primera petición no deja una escritura de fondo.
  • Los ocho checks del commit indicado están verdes. Las pruebas temporales de aceptación se guardaron fuera del worktree y se retiraron; no se cambia producto ni el clon principal.

Antes del squash se comprueba la única dependiente #242 y se reapunta a main, como se pidió. La integración cierra #138, conserva #69/#71/#128 y G2 abiertos, y no autoriza release.

@eribertocz
eribertocz merged commit 90817e4 into main Oct 24, 2026
8 checks passed
@eribertocz
eribertocz deleted the claude/138-semantic-query branch October 24, 2026 12:10
@eribertocz

Copy link
Copy Markdown
Owner Author

[Codex]

Comprobación de continuidad de la sesión interrumpida: leídos todos mis comentarios de #227 y #232–#242. Se eliminaron únicamente seis marcas BOM anteriores al prefijo [Codex] (#227, #234, #238, #239, #241 y #242); lectura posterior exacta verificada, sin cambiar pruebas, commits, resultados o veredictos. Los demás comentarios ya conservaban saltos y acentos correctos. #240 no tenía un veredicto previo: se completa en esta tanda; no se inventa uno anterior.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

[G2] Ejecución 4/4: POST semantic/query con resultado y auditoría antes de responder

1 participant