diff --git a/docs/BACKLOG.md b/docs/BACKLOG.md index 4ebfb469..e96e209e 100644 --- a/docs/BACKLOG.md +++ b/docs/BACKLOG.md @@ -5599,6 +5599,128 @@ systems. This track claims the space. ## P2 — research-grade +- [ ] **Cross-DSL composability — git / SQL / + operator-algebra / LINQ access each other seamlessly + with full index utilization.** Maintainer 2026-04-24 + directive (verbatim): + + > *"i would love to be able to see git as composable + > with the rest of the DSLs too so they all can access + > each other seamlessly and still hit indexes and get + > all the performanes and everyting. backlog and + > draing this one and contineue"* + + Scope: every first-class interface on Zeta's + substrate (git, SQL, operator algebra, LINQ, future + GraphQL / blockchain query / WASM-RPC) must compose + with every other interface. A query that mixes git + semantics + SQL semantics + operator-algebra + semantics in a single expression should: + 1. **Parse + bind** through the unified type system. + 2. **Plan** through the cost-based query optimizer + (`query-optimizer-expert`) which sees the full + mixed-DSL AST. + 3. **Hit indexes** for each constituent DSL (the + hierarchical index from the + closure-table-hardening row, the row-index from + SQL, the operator-algebra's incremental view + materialized, etc.). + 4. **Execute** with retraction-native semantics + preserved end-to-end (a git-revert in the input + stream produces a Z-set retraction in the output). + + **Cross-DSL examples (motivating use cases):** + - "SQL JOIN where left side is a git log query and + right side is a Z-set delta from operator algebra." + - "Git push where the tree is computed by a SQL + SELECT over Z-sets." + - "LINQ query over a blockchain block stream + correlated with git commits." + - "Operator-algebra incremental view that consumes + git commits AND SQL inserts, fans out into + multiple downstream Z-sets." + + **Architectural primitives required:** + - **Unified AST** spanning all DSLs (or + cross-translation matrix between DSL ASTs). + - **Plan-time optimizer** that sees the mixed + expression and chooses the right index per leaf. + Composes with `query-planner` + + `query-optimizer-expert` + `binder-expert` (need a + `binder-cross-dsl` capability). + - **Adapter pattern** between DSLs at the algebraic + layer — the operator algebra's D/I/z⁻¹/H operators + must commute with git's commit/branch/merge AND + SQL's relational operators (this is where + K-relations / semiring-parameterized Zeta + substrate from the prior research becomes + load-bearing — same algebra hosts all the + other DSLs). + - **Retraction-preserving translation** at every + boundary. + + **Composes with (load-bearing):** + - **Closure-table hierarchical index** — the + `Hierarchy.fs` closure-table operator + (`src/Core/Hierarchy.fs`) plus the "Closure-table + over DBSP" research row in this same `docs/BACKLOG.md` + under `## Research projects` (paper-grade target: + "first retraction-native incremental transitive + closure with tropical-semiring shortest-path free + variant"). The hierarchical index this query layer + hits. + - **Native F# git implementation** (#395) — git as + first-class DSL. + - **Mode 2 protocol-upgrade negotiation** (#395) — + fast protocol carries cross-DSL queries. + - **Ouroboros bootstrap meta-thesis** (#395) — + cross-DSL composability is itself an Ouroboros + closure: the system's interfaces compose with + themselves through the same substrate. + - **Semiring-parameterized Zeta substrate** — the + "one algebra to map the others" frame from the + 2026-04-22 maintainer auto-loop-38 thread (memory: + `memory/project_semiring_parameterized_zeta_regime_change_one_algebra_to_map_others_2026_04_22.md`). + This row is a direct application of that + research-changing claim: if the operator algebra + is parameterized by a semiring, every other DSL's + semantics maps into the same one algebra by + semiring-swap, and the cross-DSL composability + falls out for free. + - **Blockchain ingest** (#394) — chain queries + compose with git/SQL queries via the same + substrate. + + **Phased approach:** + - **Phase 0** — design proposal: + `docs/research/cross-dsl-composability-2026.md`. + Interface map between every pair of DSLs. + Identify the canonical algebra (the operator + algebra under semiring-param) as the unifying + layer. Empirically verify a representative + cross-DSL query plans + executes correctly on a + small workload. + - **Phase 1** — pairwise adapters: git ↔ SQL, SQL + ↔ operator-algebra, etc. + - **Phase 2** — unified planner / binder. + - **Phase 3** — index-utilization audit: every + leaf-DSL must hit its native index in mixed + expressions. + - **Phase 4** — retraction-preservation at every + boundary (formal proof or property-based + verification). + + Priority P2 research-grade; effort L+ (Phase 0 + research) + L+L+M+L (Phases 1-4). Composes with + Otto-275 log-don't-implement. + + **Does NOT authorize** starting implementation + without Phase 0 research landing. **Does NOT + authorize** declaring composability "done" without + empirical evidence that mixed-DSL queries hit ALL + applicable indexes (no full-scan fallback for + composed leaves). + - [ ] **Blockchain block ingestion — first-class BTC / ETH / SOL streaming into Zeta's distributed database; bi-directional protocol participation; cross-chain diff --git a/docs/pr-preservation/397-drain-log.md b/docs/pr-preservation/397-drain-log.md new file mode 100644 index 00000000..014da149 --- /dev/null +++ b/docs/pr-preservation/397-drain-log.md @@ -0,0 +1,177 @@ +# PR #397 drain log — cross-DSL composability BACKLOG row + +PR: +Branch: `backlog/cross-dsl-composability` +Drain session: 2026-04-24 (Otto) +Thread count at drain start: 5 unresolved + +Per Aaron's 2026-04-24 PR-comment-preservation directive: +full per-thread record with verbatim reviewer text, outcome, +verbatim reply, and resolution commit. Docs-only PR adding a +single P2 research-grade BACKLOG row for git/SQL/operator- +algebra/LINQ cross-DSL composability under semiring- +parameterized substrate. + +--- + +## Thread 1 — `docs/BACKLOG.md:5664` — closure-table dependency pointer + +- Reviewer: `copilot-pull-request-reviewer` +- Thread ID: `PRRT_kwDOSF9kNM59iQrr` +- Severity: P2 + +### Original comment (verbatim) + +> **P2 Badge** Point to an existing backlog dependency +> +> This dependency note says the work composes with a +> "Closure-table hardening" row in the same `docs/BACKLOG.md` +> section, but there is no such row anywhere in the file +> (repo-wide search in `docs/BACKLOG.md` only finds this +> mention). That leaves this item with an unresolvable +> prerequisite, which weakens planning/ordering for the +> research phases because readers cannot find the referenced +> index-hardening task to scope or schedule it. + +### Outcome + +FIX — pointer made concrete. The "same section" wording was +wrong; the actual matching surfaces are `src/Core/Hierarchy.fs` +(live closure-table operator) plus the "Closure-table over +DBSP" research row under `## Research projects`. Bullet +rewritten to name both targets so a reader can navigate to +either the code or the paper-grade research row. + +### Reply (verbatim) + +> Fixed. Pointer rewritten to name two concrete surfaces: +> `src/Core/Hierarchy.fs` (live closure-table operator) and +> the "Closure-table over DBSP" research row under +> `## Research projects` in `docs/BACKLOG.md`. The original +> "same section" wording was wrong — the dependency lives in +> two places (code + research row in a different section), +> not a single hardening row in this P2 section. Resolved. + +--- + +## Thread 2 — `docs/BACKLOG.md:5604` — title hyphen split + +- Reviewer: `copilot-pull-request-reviewer` +- Thread ID: `PRRT_kwDOSF9kNM59iRTm` +- Severity: P1 + +### Original comment (verbatim) + +> P1: The line break in the checklist title splits a hyphenated +> term (`operator-` / `algebra`), which will render as +> "operator- algebra" in Markdown. Rewrap so `operator-algebra` +> stays intact (or remove the hyphen). + +### Outcome + +FIX — title rewrapped so `operator-algebra` stays on one line. +Soft line break moved between `SQL /` and `operator-algebra`. + +### Reply (verbatim) + +> Fixed. Title rewrapped so `operator-algebra` is contiguous +> on a single line. Resolved. + +--- + +## Thread 3 — `docs/BACKLOG.md:5626` — closure-table-hardening hyphen split + +- Reviewer: `copilot-pull-request-reviewer` +- Thread ID: `PRRT_kwDOSF9kNM59iRT1` +- Severity: P1 + +### Original comment (verbatim) + +> P1: This line wrap splits "closure-table-" from "hardening", +> which will render as "closure-table- hardening". Please +> rewrap without breaking the hyphenated token (or drop the +> trailing hyphen). + +### Outcome + +FIX — bullet rewrapped so `closure-table-hardening` stays +contiguous on a single line. Subsequent paragraph reflowed. + +### Reply (verbatim) + +> Fixed. Bullet rewrapped so `closure-table-hardening` is +> contiguous on a single line; subsequent text reflowed. +> Resolved. + +--- + +## Thread 4 — `docs/BACKLOG.md:5650` — query-optimizer-expert inline-code split + +- Reviewer: `copilot-pull-request-reviewer` +- Thread ID: `PRRT_kwDOSF9kNM59iRT8` +- Severity: P0 + +### Original comment (verbatim) + +> P0: The inline-code reference to `query-optimizer-expert` is +> split across lines as `query-optimizer-` / `expert`, which +> renders incorrectly (and can break readability/search). +> Rewrap so the inline-code token stays contiguous on one line. + +### Outcome + +FIX — bullet rewrapped so the inline-code token +`` `query-optimizer-expert` `` stays contiguous on a single +line. Subsequent lines reflowed. + +### Reply (verbatim) + +> Fixed. Bullet rewrapped so the inline-code token +> `query-optimizer-expert` is contiguous on a single line; +> the surrounding text reflowed without breaking other +> inline-code tokens. Resolved. + +--- + +## Thread 5 — `docs/BACKLOG.md:5677` — memory/ prefix on memory pointer + +- Reviewer: `copilot-pull-request-reviewer` +- Thread ID: `PRRT_kwDOSF9kNM59iRUJ` +- Severity: P1 + +### Original comment (verbatim) + +> P1: The memory reference is missing the `memory/` prefix +> (`project_semiring_parameterized_...`) unlike other BACKLOG +> entries (e.g. the existing semiring row uses +> `memory/project_semiring_parameterized_...`). Using the full +> `memory/...` path here avoids ambiguous references and makes +> the pointer unambiguous. + +### Outcome + +FIX — `memory/` prefix added to the memory pointer to match +the existing convention used at lines 7316 and 7409 of +`docs/BACKLOG.md`. + +### Reply (verbatim) + +> Fixed. Added the `memory/` prefix to the pointer +> (`memory/project_semiring_parameterized_zeta_regime_change_one_algebra_to_map_others_2026_04_22.md`) +> to match the convention used by the existing semiring rows +> at lines 7316 and 7409 of `docs/BACKLOG.md`. Resolved. + +--- + +## Rebase summary + +- Branch `backlog/cross-dsl-composability` rebased cleanly + on `origin/main` (no conflict markers, no cascade). +- Thread fixes landed as a single follow-up commit on top of + the rebase. + +## Final state + +- Unresolved threads: 0 +- Auto-merge: armed (squash) +- Mergeable: MERGEABLE (pending CI re-run)