@@ -226,7 +226,7 @@ packages/structured-data-models-client/src/sdm_client/
 - The validated-query format is versioned and locked apart from the contract (E8), and is provisional until the PQL asks are answered.
 - Today's ANTLR grammar is the CI reference through the reference observations and the corpus recorded on it; Phase 1 adds no separate grammar check.
 - Every tree level counts against `MAX_DEPTH`, AND and OR links included; the adapter grows the stack once and builds its result and drops the tree inside it; the validated-query format is read back with `serde_stacker`, so the deepest accepted tree round-trips and the first rejected depth is refused (H27).
-  As built at T1.7c: a chain's first condition takes a level of its own, so 999 nested NOTs or parentheses are the deepest accepted and 1,000 refused, while an AND or OR chain of 998 links is accepted and 999 refused; 10,000 links are refused at the limit on a 256 KB thread. `sdm_core::pql::on_adapter_stack` is the one place a stack grows. `KNOWN_DIFFERING` is `sdm-core/tests/pql/known-differing.json`, naming per case the parts that differ (answer, validity, tree, readings, errors or warnings), so the D4 case is pinned for its warning only; `corpus.json` (format 2) carries the reference's date readings, recorded by `record_readings.py`, and `journey.json` (format 2) the six skipped inventory IDs.
+  As built at T1.7c: the parser bounds both its own nesting and the height of every condition tree it builds (a comparison one level, a NOT or parenthesis one more than what it holds, a link one more than its taller side, a filtered aggregation's condition and nested arrays below their comparison), so no mix of NOT, parentheses, AND, OR and arrays builds a tree past `MAX_DEPTH`; 999 nested NOTs or parentheses are the deepest accepted and 1,000 refused, an AND or OR chain of 998 links is accepted and 999 refused, and 10,000 links, NOTs under a long chain, or chains nested in groups are refused at the limit in bounded time. A deferred date literal's refusal gives its position as fields, never its text. `sdm_core::pql::on_adapter_stack` is the one place a stack grows. `KNOWN_DIFFERING` is `sdm-core/tests/pql/known-differing.json`, naming per case the parts that differ (answer, validity, tree, readings, errors or warnings), so the D4 case is pinned for its warning only; `corpus.json` (format 2) carries the reference's date readings, recorded by `record_readings.py`, and `journey.json` (format 2) the six skipped inventory IDs.
 - Only `sdm-core` has a production dependency on the crate, and only its adapter uses it; the PQL team's crate later goes behind the same function.
 - `scripts/rust_core/emulation-allowlist.txt` holds exactly those three modules; emulation is banned everywhere else, each addition needs an owner-approved decisions row, and the list expires with the crate (H21).
 - Its header states the line: porting the reference's own defined algorithms (`DateOffset` arithmetic in `dor.rs`, `str.isspace` in `syntax.rs`, the `query[:-1]` quirk in `visitor.rs`, and T1.25's `text_shapes`) is a port with a row in `dependencies.md`; emulation is copying a library's incidental behavior, such as a codec or a repr.
 
@@ -16,7 +16,7 @@ A task's checks are active from the moment it lands, as listed in the design's t
 | T1.6a Interim parser port and adapter | 1a | done | c01d79e, dbb10d8, 7a425a3, 23acca0; CI run 37802846877 green (`rust-lint` checks both schema locks; `rust-test`: the 417-query corpus through the adapter, 416 agreeing, the 34 journey queries recorded on the reference, the adapter's own tests) | The archive's parser and seven validators behind `sdm_core::pql`, capability checks in `sdm-core` (the pre-resolution `MODEL_NO_TEMPORAL_TARGET` check; the two filter capabilities consulted in resolution, E11); contract version 2 with PQL's row and column spans (E7); the validated-query format, version 1, locked apart (E8); the allowlist holds `pyint`, `float_repr` and `escapes` (E9); an interim date reader without D4's warning and D8 (E10); the corpus and journey queries live in `sdm-core/tests/pql` (E12). The one corpus difference is D4's warning; message text is not promised and differs |
 | T1.7 `sdm-host` | 1a | done | a7a5a02, 4ebb1ae, 1b7b68e; CI run 37804761504 green, every job (`rust-test`: `sdm-host` codec 7, admission 8, runs 12 tests; `sdm-core` `Run::end`) | Codecs and the 64 KB cap; the admission table, with `VALUE_OUT_OF_RANGE` for a value the admitted type cannot hold; `HostRun` with bytes in and out, contained calls, `RUN_BUSY`, E2's attachment rules, admission refusals ending the run (`Run::end`), and zones per run from the host facts (E13). The batch 2 code review's blockers (an uncatchable stack overflow on long AND chains; refusals of types the reference accepts) and should-fix items are T1.7c's exit (H27); the exit refuses only families that cannot convert losslessly |
 | T1.7b Contract v3 | 1a | in progress | Topic branch `rust-core-phase-1-t1.7b` at 305c73c (after the review fixes), one package, CI run 37830953836 green on it, every job; `BASE_SHA` c17d51891b2720e931309f55b9738bcd05d625ef (the phase tip at package start), `CHECKPOINT_SHA` the same (the candidate's merge base with it); before T1.14 the candidate's own harness runs and no acceptance is claimed. Exit tests: `sdm-host` `contract_v3` (11: another contract version refused first; the 5,000-column schema with a query past 64 KB, the start envelope and attachments either side of the cap, the wide `Fetch` step, the `validate_query` result, a real validation past the cap, the error and the warnings, each arriving whole; the run-numbered attachment; retryability; POSIX local zones), `codec` (the codec-level `Done` with a `SourceDescription` either side of the cap); `sdm-contract` `messages` (seed `2**70`, `Span` rows from 1, `ErrorCode`, provider errors without text) and `schema_lock` (the annotation-free hash); `sdm-core` `dispatch` (start attachments, the negative seed); `tests/test_rust_contract.py` (working entry, merged entries, the projection) | Contract version 3 (E15): input-sized fields as attachments (H5); exhaustive `ErrorCode` with `retryable` (H6); the hex seed, the annotation-free hash, over-cap core messages as `attached` (H7); errors from `HostRun` as control messages; the lock collapsed to one working entry (H4); test-only operations behind `test-ops`. Awaiting independent review and landing; owner check-in after it (H12) |
-| T1.7c Batch 1 and 2 code fixes | 1a | in progress | Topic branch `rust-core-phase-1-t1.7c`, one package, stacked on T1.7b's candidate 305c73c because its exit needs v3 (over-cap output, test-only operations through `HostRun::start`); `BASE_SHA` c17d51891b2720e931309f55b9738bcd05d625ef and `CHECKPOINT_SHA` the same until T1.7b lands, then rebased onto that landing with both reset. Exit tests: `sdm-host` `faults` (check (a): an extra column, swapped same-typed columns, a decimal scale, a timestamp unit, metadata, a later batch; check (b): a column lacking, added, renamed, reordered or of another type; panics at start, in the body and on the adapter's stack; `fields.panic` not poisoning; canaries in errors and, in a child process, stderr), `widening` (each widened type's values, validity and received type; split and single-value refusal at a test-only capacity; the still-refused list against HOST-2), `admission` (refusals name the type received), `runs`; `sdm-core` `pql_adapter` (10,000-link chains, depth boundaries, DT-9 pinned, E11 precedence), `pql_stack` (one stack per call, the deepest validated query round-trips), `pql_corpus` (`KNOWN_DIFFERING`, readings, multiset errors), `pql_journey` (34 cases, six skipped by name) | H16, H17 and H27 as built (design, "Core, host and binding" and "Interim parser"). Before T1.14 the candidate's own harness runs; no acceptance is claimed. Awaiting independent review and landing |
+| T1.7c Batch 1 and 2 code fixes | 1a | in progress | Topic branch `rust-core-phase-1-t1.7c`, one package, stacked on T1.7b's candidate 305c73c because its exit needs v3 (over-cap output, test-only operations through `HostRun::start`); `BASE_SHA` c17d51891b2720e931309f55b9738bcd05d625ef and `CHECKPOINT_SHA` the same until T1.7b lands, then rebased onto that landing with both reset. Exit tests: `sdm-host` `faults` (check (a): an extra column, swapped same-typed columns, a decimal scale, a timestamp unit, metadata, a later batch; nulls in a non-nullable column; check (b): a column lacking, added, renamed, reordered, of another type, without required metadata or with nulls the request does not take; panics at start, in the body and on the adapter's stack; `fields.panic` not poisoning; canaries in malformed messages and attachments, Arrow values and a credential, and panic payloads, in errors and, in a child process, stderr; the adapter-stack panic is inside the interim parser), `widening` (each widened type's values, validity and received type; split and single-value refusal at a test-only capacity; ), `admission` (refusals name the type received; the still-refused families, generated from the family table, against HOST-2), `runs`; `sdm-core` `pql_adapter` (10,000-link chains, trees tall by NOTs under a chain or nested groups refused in bounded time, depth boundaries, DT-9 pinned without quoting the literal, E11 precedence), `pql_stack` (one stack per call, the tallest accepted query of each shape and mix round-trips), `pql_corpus` (`KNOWN_DIFFERING`, readings, multiset errors), `pql_journey` (34 cases, six skipped by name) | H16, H17 and H27 as built (design, "Core, host and binding" and "Interim parser"). Before T1.14 the candidate's own harness runs; no acceptance is claimed. Awaiting independent review and landing |
 | T1.8 `sdm-py`, the client wheel and CI rewiring | 1a | not started | | From T1.7: bind `HostRun` (bytes in and out, attachments by id) and raise `_native.CoreError` from the error it returns; containment is already in `sdm-host`. From re-review: the `pyo3-log` bridge with `tracing`'s `log` feature, GIL, clean-import and abort tests, and a delivered log record (H8, F5); the local macOS build for the reference comparisons, its SHA-256 in identity (owner answer 5) |
 | T1.9 Python host and routing seam | 1a | not started | | The exhaustive error mapping (H6); the level-cache reset; no chained driver exception (H17); a wide-schema `materialize()` through the installed wheel (H5) |
 | T1.10 First S0 case on every runner | 1a | not started | | Guard name list updated on `rust-core-reference` before any reference observation is recorded; records through `run_python.py` in `python-ref` mode until T1.14 lands `gate.sh`; `python-old` is a smoke runner (H10); a recorded `RuntimeError` is an outcome, not a runner failure |
 
@@ -845,16 +845,18 @@ entries:
     ms, date64 (as timestamp[us]), view types, fixed_size_binary and any
     dictionary are admitted, keeping the received type; a batch whose values
     pass int32 offsets is split between rows. Proposed: what still cannot
-    convert is refused by name. Generated at T1.7c by the admission tests
-    (sdm-host tests/widening.rs, which fail if this list and the code
-    disagree), the type families still refused are `interval`,
-    `run_end_encoded` and `union`; interval and union are refused by the
-    reference too (inventory cases time.feature-interval and nested.union),
-    so run_end_encoded is the one type family that needs the owner. The
-    values still refused are a timestamp, duration or date64 at s or ms
-    whose value passes int64 microseconds, and a single string, binary or
-    list value past int32 offsets; any type T1.33 finds no lossless row for
-    joins them.
+    convert is refused by name. Generated at T1.7c from the admission
+    tests' family table (sdm-host tests/admission.rs, which fails if this
+    list and the code disagree), the type families still refused are
+    `interval`, `run_end_encoded` and `union`. The reference refuses
+    interval and union where it infers a column's type (inventory cases
+    time.feature-interval and nested.union), but a column given an
+    explicit dtype skips that inference (table.py), so the reference may
+    read all three there, and each needs the owner. The values still
+    refused are a timestamp, duration or date64 at s or ms whose value
+    passes int64 microseconds, and a single string, binary or list value
+    past int32 offsets; any type T1.33 finds no lossless row for joins
+    them.
   affected_inputs: Sources returning Arrow types outside the closed set with no lossless conversion.
   cases: [T1.7c, T1.33]
   status: proposed
 
@@ -14,7 +14,7 @@ publish.workspace = true
 
 [features]
 # Operations only tests reach; a shipped build leaves it off.
-test-ops = ["sdm-contract/test-ops"]
+test-ops = ["sdm-contract/test-ops", "sdm-pql-interim/test-ops"]
 
 [dependencies]
 arrow-array.workspace = true
 
@@ -89,7 +89,7 @@ pub fn start(
             Run::new(|_| async { Err(not_yet("predict")) })
         }
         #[cfg(feature = "test-ops")]
-        Operation::Test(operation) => crate::test_ops::run(operation, &mut attachments)?,
+        Operation::Test(operation) => crate::test_ops::run(operation, &mut attachments, facts)?,
     })
 }
 
 
@@ -154,15 +154,26 @@ fn is_error(diagnostic: &PqlDiagnostic) -> bool {
     diagnostic.severity == Severity::Error
 }
 
+/// The refusal of a query the interim parser cannot read yet: where the
+/// literal is, as fields, never the literal itself (decision H17).
 fn unsupported(interrupted: interim::Interrupted) -> CoreError {
-    CoreError::new(
+    let mut error = CoreError::new(
         ErrorKind::Unsupported,
         ErrorCode::UnsupportedRequest,
         format!(
             "{}; the interim PQL parser cannot validate this query",
-            interrupted.0
+            interim::ast::DEFERRED
         ),
-    )
+    );
+    if let Some(at) = interrupted.0 {
+        let count = |n: usize| Detail::Scalar(Scalar::UInt64(u64::try_from(n).unwrap_or(u64::MAX)));
+        error = error
+            .with_field("start_row", count(at.start_row))
+            .with_field("start_col", count(at.start_col))
+            .with_field("end_row", count(at.end_row))
+            .with_field("end_col", count(at.end_col));
+    }
+    error
 }
 
 fn internal(message: impl Into<String>) -> CoreError {
@@ -449,7 +460,9 @@ fn literal(n: &NodeRef, value: &ConstValue) -> Result<PqlLiteral, CoreError> {
         }
         ConstValue::Text(text) => text,
     };
-    let read = ast::typed_value(n).map_err(|e| internal(format!("a validated constant: {e}")))?;
+    let read = ast::typed_value(n)
+        // The reader's text may quote the constant, which is input.
+        .map_err(|_| internal("a validated constant could not be read as its type"))?;
     Ok(match read {
         Literal::Null => PqlLiteral::Null,
         Literal::Bool(value) => PqlLiteral::Bool { value },
 
@@ -5,17 +5,19 @@
 //! The bodies of the test-only operations (`sdm_contract::test_ops`), built
 //! only with the `test-ops` feature, which a shipped build leaves off.
 
-use sdm_contract::ops::OperationResult;
+use sdm_contract::ops::{OperationResult, ProfileName, ProfileSpec, QuerySchema};
 use sdm_contract::test_ops::{PanicAt, TestFetch, TestOperation, TestResult};
-use sdm_contract::{CoreError, CoreWarning};
+use sdm_contract::{CoreError, CoreWarning, HostFacts};
 
 use crate::attached::take_json;
+use crate::profiles::Profile;
 use crate::run::{Attachments, FetchResult, Reply, Run, internal};
 
 /// The run of a test-only operation.
 pub(crate) fn run(
     operation: TestOperation,
     attachments: &mut Attachments,
+    facts: HostFacts,
 ) -> Result<Run, CoreError> {
     Ok(match operation {
         TestOperation::Fetch { fetch } => {
@@ -51,10 +53,20 @@ pub(crate) fn run(
         TestOperation::Panic { at, payload } => match at {
             PanicAt::Start => panic!("{payload}"),
             PanicAt::Body => Run::new(move |_| async move { panic!("{payload}") }),
+            // Inside the interim parser, on the adapter's grown stack.
             PanicAt::AdapterStack => Run::new(move |_| async move {
-                crate::pql::on_adapter_stack(move || -> Result<OperationResult, CoreError> {
-                    panic!("{payload}")
-                })
+                sdm_pql_interim::parser::panic_in_next_parse(payload);
+                let profile = Profile::resolve(&ProfileSpec {
+                    name: ProfileName::Relational,
+                    model: None,
+                    capabilities: Default::default(),
+                });
+                let schema = QuerySchema {
+                    tables: vec![],
+                    links: vec![],
+                };
+                crate::pql::validate("PREDICT t.c FOR EACH t.id", &schema, &profile, &facts)
+                    .map(OperationResult::ValidateQuery)
             }),
         },
     })
 
@@ -412,5 +412,17 @@ fn a_date_the_reference_reads_and_the_interim_reader_does_not_is_pinned_as_refus
             (ErrorKind::Unsupported, ErrorCode::UnsupportedRequest),
             "{literal}"
         );
+        // The literal is input: the refusal gives its position, never its
+        // text (decision H17).
+        let written = format!("{} {err:?}", serde_json::to_string(&err).unwrap());
+        assert!(!written.contains(literal), "{written}");
+        assert!(!written.contains(&literal[..8]), "{written}");
+        assert_eq!(
+            err.fields.get("start_row"),
+            Some(&sdm_contract::Detail::Scalar(sdm_contract::Scalar::UInt64(
+                1
+            )))
+        );
+        assert!(err.fields.contains_key("start_col"));
     }
 }
@@ -504,3 +504,35 @@ fn a_refused_child_is_named_by_its_path() {
     let err = admitted_type("col", &dictionary).unwrap_err();
     assert_eq!(text(&err, "arrow_type"), interval.to_string());
 }
+
+/// The backticked names in register HOST-2's entry: the type families it
+/// lists as still refused.
+fn host_2_families() -> BTreeSet<String> {
+    let register = std::fs::read_to_string(
+        std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../../docs/design/rust-core/register.yaml"),
+    )
+    .unwrap();
+    let start = register.find("- id: HOST-2\n").expect("register HOST-2");
+    let entry = &register[start + 1..];
+    let entry = &entry[..entry.find("\n- id: ").unwrap_or(entry.len())];
+    entry
+        .split('`')
+        .skip(1)
+        .step_by(2)
+        .map(str::to_owned)
+        .collect()
+}
+
+#[test]
+fn the_families_still_refused_are_the_ones_register_host_2_lists() {
+    // Generated from the family table above, so a widening or a new
+    // refusal changes it, and then HOST-2 must say so.
+    let refused: BTreeSet<String> = every_family()
+        .iter()
+        .map(family)
+        .filter(|(_, taken)| *taken == Family::Outside)
+        .map(|(name, _)| name.to_owned())
+        .collect();
+    assert_eq!(refused, host_2_families());
+}
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ pub fn start(`
`89`	`89`	`Run::new(\|_\| async { Err(not_yet("predict")) })`
`90`	`90`	`}`
`91`	`91`	`#[cfg(feature = "test-ops")]`
`92`		`- Operation::Test(operation) => crate::test_ops::run(operation, &mut attachments)?,`
	`92`	`+ Operation::Test(operation) => crate::test_ops::run(operation, &mut attachments, facts)?,`
`93`	`93`	`})`
`94`	`94`	`}`
`95`	`95`