deepparallel 0.3.1__tar.gz → 0.4.1__tar.gz

{deepparallel-0.3.1 → deepparallel-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.3.1
+Version: 0.4.1
 Summary: DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic.
 Author-email: Michael Crowe <michael@crowelogic.com>
 License: Apache-2.0
@@ -19,6 +19,8 @@ Requires-Dist: cryptography>=42.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: ruff>=0.6.0; extra == "dev"
+Provides-Extra: research
+Requires-Dist: numpy>=1.24; extra == "research"
 
 # DeepParallel
 
@@ -67,6 +69,7 @@ Set the backend env vars (a `.env` file in the working directory is loaded autom
     deepparallel run --yes "..."        # auto-approve tool actions
     deepparallel review <file|--diff>   # cross-model review as a CI gate (Pro)
     deepparallel audit <file>           # supply-chain gate: catch hallucinated deps (Pro)
+    deepparallel research conduit       # latent-relay research demo (needs [research] extra)
 
 ## Supply-chain gate
 

{deepparallel-0.3.1 → deepparallel-0.4.1}/README.md

@@ -45,6 +45,7 @@ Set the backend env vars (a `.env` file in the working directory is loaded autom
     deepparallel run --yes "..."        # auto-approve tool actions
     deepparallel review <file|--diff>   # cross-model review as a CI gate (Pro)
     deepparallel audit <file>           # supply-chain gate: catch hallucinated deps (Pro)
+    deepparallel research conduit       # latent-relay research demo (needs [research] extra)
 
 ## Supply-chain gate
 

{deepparallel-0.3.1 → deepparallel-0.4.1}/deepparallel/__init__.py

@@ -1,3 +1,3 @@
 """DeepParallel CLI package."""
 
-__version__ = "0.3.1"
+__version__ = "0.4.1"

{deepparallel-0.3.1 → deepparallel-0.4.1}/deepparallel/cli.py

@@ -546,6 +546,52 @@ def audit(ctx: click.Context, path: str) -> None:
     sys.exit(0)
 
 
+@main.group()
+def research() -> None:
+    """Runnable demonstrators of the ideas behind DeepParallel."""
+
+
+@research.command("conduit")
+def research_conduit() -> None:
+    """Conduit: relay a thought between models as a hidden state vs. as a word.
+
+    Frozen synthetic models relay a continuous meaning down a chain of agents two
+    ways and we measure how much survives each hop. The latent channel holds the
+    meaning; the word channel (one emitted token per hop) collapses. The same
+    result on real open-weight models: crowelogic.com/research/conduit
+    """
+    try:
+        from deepparallel.research import conduit as _conduit
+    except ImportError:
+        branding.error(
+            "this demo needs numpy. Install it with: pip install 'deepparallel[research]'"
+        )
+        sys.exit(3)
+    console.print(f"[{branding.DIM}]running the latent relay (frozen synthetic models)...[/]")
+    r = _conduit.demonstrate()
+    console.print(
+        f"\n[bold]Conduit[/] · meaning retained after K relay hops "
+        f"[{branding.DIM}](cosine; 1.0 = perfect)[/]"
+    )
+    console.print(
+        f"[{branding.DIM}]  meaning = {r['meaning_dim']}-dim continuous   "
+        f"word channel = 1 token of {r['vocab']}[/]\n"
+    )
+    console.print(
+        f"  [{branding.DIM}]{'hops':>5}   {'latent relay':>13}   {'word relay':>11}   {'gain':>6}[/]"
+    )
+    for K in r["hops"]:
+        lat, wrd = r["latent"][K], r["word"][K]
+        console.print(
+            f"  {K:>5}   [{branding.GREEN_HEX}]{lat:>13.3f}[/]   "
+            f"[{branding.DIM}]{wrd:>11.3f}[/]   [{branding.AMBER_HEX}]{lat - wrd:>+6.3f}[/]"
+        )
+    console.print(
+        f"\n[{branding.DIM}]  the full hidden state relays more meaning than the single word "
+        f"the model would have said.[/]"
+    )
+
+
 @main.command(name="tools")
 def tools_cmd() -> None:
     """List the agent tools available to DeepParallel."""

{deepparallel-0.3.1 → deepparallel-0.4.1}/deepparallel/renderer.py

@@ -25,6 +25,15 @@ from deepparallel import branding
 _REVEAL_SECONDS = 0.04  # per-line delay for the animated intro (tests set 0)
 
 
+def _balance_fences(text: str) -> str:
+    """Close a dangling ``` while streaming so a half-arrived code block renders
+    as code instead of leaking its fence as literal text. The closing fence is
+    cosmetic for the in-progress frame; the final frame has the real one."""
+    if text.count("```") % 2 == 1:
+        return text + "\n```"
+    return text
+
+
 class Renderer(ABC):
     @abstractmethod
     def welcome(
@@ -146,10 +155,18 @@ class RichRenderer(Renderer):
         self._console.print(branding.build_transcript_markdown(self._console, text))
 
     def answer_stream(self, chunks: Iterable[str]) -> str:
-        # Inline token streaming: no Live/transient panels, so it never ghosts
-        # in wide terminals or when tool turns interleave. The marker is printed
-        # only on the first VISIBLE character, so empty / whitespace-leading
-        # (tool-only) turns render no stray marker.
+        """Stream the answer. On a real terminal, render Markdown live in a panel
+        that grows as tokens arrive (headings, code, lists format in place); the
+        final frame is the same panel `answer()` would print, so there is no
+        double render. On a pipe / non-tty, fall back to raw inline streaming."""
+        if self._console.is_terminal:
+            return self._stream_live_markdown(chunks)
+        return self._stream_inline(chunks)
+
+    def _stream_inline(self, chunks: Iterable[str]) -> str:
+        # Raw token streaming for pipes / non-tty: no Live, never ghosts. The
+        # marker is printed only on the first VISIBLE character, so empty /
+        # whitespace-leading (tool-only) turns render no stray marker.
         parts: list[str] = []
         started = False
         for c in chunks:
@@ -158,7 +175,7 @@ class RichRenderer(Renderer):
                 self._console.print(c, end="", soft_wrap=True, highlight=False, markup=False)
                 continue
             if not "".join(parts).strip():
-                continue  # only whitespace so far; hold the marker back
+                continue
             started = True
             self._console.print(
                 f"[{branding.DP_ACCENT}]{branding.MARK}[/] ", end="", highlight=False
@@ -168,6 +185,39 @@ class RichRenderer(Renderer):
             self._console.print()
         return "".join(parts)
 
+    def _stream_live_markdown(self, chunks: Iterable[str]) -> str:
+        from rich.live import Live
+
+        parts: list[str] = []
+        started = False
+        last_draw = 0.0
+        live = Live(
+            console=self._console,
+            auto_refresh=False,  # we drive refreshes; deterministic, no bg thread
+            vertical_overflow="visible",  # let answers taller than the screen scroll
+        )
+        try:
+            for c in chunks:
+                parts.append(c)
+                if not started:
+                    if not "".join(parts).strip():
+                        continue  # hold the panel back until real content arrives
+                    started = True
+                    live.start()
+                now = time.monotonic()
+                if now - last_draw >= 0.06:  # throttle to ~16 fps
+                    live.update(self._answer_panel("".join(parts)), refresh=True)
+                    last_draw = now
+            if started:  # final frame: the complete, settled answer
+                live.update(self._answer_panel("".join(parts)), refresh=True)
+        finally:
+            if started:
+                live.stop()
+        return "".join(parts)
+
+    def _answer_panel(self, text: str):
+        return branding.build_transcript_markdown(self._console, _balance_fences(text))
+
     def reasoning(self, text: str) -> None:
         self._console.print(branding.build_reasoning_panel(self._console, text))
 

deepparallel-0.4.1/deepparallel/research/__init__.py

@@ -0,0 +1,6 @@
+"""DeepParallel research demonstrators.
+
+Self-contained, runnable illustrations of the ideas behind DeepParallel's
+multi-model approach. These are optional and depend on numpy; install with
+`pip install deepparallel[research]`.
+"""

deepparallel-0.4.1/deepparallel/research/conduit.py

@@ -0,0 +1,156 @@
+"""Conduit: latent-state relay between frozen models (runnable demonstrator).
+
+The idea behind DeepParallel's multi-model approach, made concrete. When agents
+collaborate by writing words and reading them back, every hand-off squeezes a
+continuous thought through a single emitted token (~log2(vocab) bits). Conduit
+relays the model's hidden state directly through a tiny connector instead.
+
+This is a dependency-light demonstration of the mechanism and the information
+loss it avoids: two FROZEN synthetic transformers of different hidden sizes (so
+the connector is genuinely required) relay a continuous meaning vector down a
+chain of agents two ways, and we measure how much meaning survives each hop:
+
+    latent : h_i -> connector(W) -> next model    (continuous)
+    word   : h_i -> argmax token -> re-embed       (one discrete symbol)
+
+Needs numpy (`pip install deepparallel[research]`). The full research, including
+the same result on real open-weight models, is at crowelogic.com/research/conduit.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def _gelu(x):
+    return 0.5 * x * (1.0 + np.tanh(0.7978845608 * (x + 0.044715 * x**3)))
+
+
+def _ln(x):
+    return (x - x.mean(-1, keepdims=True)) / (x.std(-1, keepdims=True) + 1e-5)
+
+
+def _softmax(x):
+    e = np.exp(x - x.max(-1, keepdims=True))
+    return e / e.sum(-1, keepdims=True)
+
+
+class _FrozenLM:
+    """A tiny frozen decoder-only transformer with its own hidden size + vocab."""
+
+    def __init__(self, vocab, d, n_layers, seed):
+        self.vocab, self.d = vocab, d
+        rng = np.random.default_rng(seed)
+        s = 1.0 / np.sqrt(d)
+        self.E = rng.standard_normal((vocab, d)) * 0.02
+        self.U = rng.standard_normal((d, vocab)) * s
+        self.layers = [
+            {
+                "Wq": rng.standard_normal((d, d)) * s,
+                "Wk": rng.standard_normal((d, d)) * s,
+                "Wv": rng.standard_normal((d, d)) * s,
+                "Wo": rng.standard_normal((d, d)) * s,
+                "W1": rng.standard_normal((d, 4 * d)) * s,
+                "W2": rng.standard_normal((4 * d, d)) * s,
+            }
+            for _ in range(n_layers)
+        ]
+
+    def _forward(self, x):
+        T = x.shape[0]
+        mask = np.triu(np.full((T, T), -1e9), k=1)
+        for p in self.layers:
+            h = _ln(x)
+            q, k, v = h @ p["Wq"], h @ p["Wk"], h @ p["Wv"]
+            att = _softmax(q @ k.T / np.sqrt(self.d) + mask)
+            x = x + (att @ v) @ p["Wo"]
+            x = x + _gelu(_ln(x) @ p["W1"]) @ p["W2"]
+        return x
+
+    def hidden_at(self, in_embed):
+        return self._forward(in_embed.reshape(1, self.d))[-1]
+
+    def next_token(self, hidden):
+        return int(np.argmax(hidden @ self.U))
+
+
+def _ridge(X, Y, lam=1e-2):
+    Xb = np.hstack([X, np.ones((X.shape[0], 1))])
+    return np.linalg.solve(Xb.T @ Xb + lam * np.eye(Xb.shape[1]), Xb.T @ Y)
+
+
+def _affine(W, x):
+    return np.hstack([x, np.ones((x.shape[0], 1))]) @ W
+
+
+class _Conduit:
+    def __init__(self, d_meaning, dims, vocab, seed=7):
+        self.dm = d_meaning
+        rng = np.random.default_rng(seed)
+        self.models = [
+            _FrozenLM(vocab, dims[0], 2, seed + 1),
+            _FrozenLM(vocab, dims[1], 2, seed + 2),
+        ]
+        self.P = [rng.standard_normal((d_meaning, m.d)) * 0.5 for m in self.models]
+        self.conn, self.readout = {}, {}
+
+    def _encode(self, mi, z):
+        return self.models[mi].hidden_at(z @ self.P[mi])
+
+    def _relay(self, z, K, path):
+        mi = 0
+        h = self._encode(mi, z)
+        for hop in range(1, K + 1):
+            mj = hop % len(self.models)
+            if path == "latent":
+                in_embed = _affine(self.conn[(mi, mj)], h.reshape(1, -1))[0]
+            else:
+                tok = self.models[mi].next_token(h)
+                in_embed = self.models[mj].E[tok]
+            h = self.models[mj].hidden_at(in_embed)
+            mi = mj
+        return h, mi
+
+    def fit(self, n_train, fit_hops, seed=0):
+        rng = np.random.default_rng(seed)
+        Z = rng.standard_normal((n_train, self.dm))
+        n = len(self.models)
+        for i in range(n):
+            Hi = np.array([self._encode(i, z) for z in Z])
+            for j in range(n):
+                self.conn[(i, j)] = _ridge(Hi, Z @ self.P[j])
+        for path in ("latent", "word"):
+            finals = {0: [], 1: []}
+            targets = {0: [], 1: []}
+            for K in fit_hops:
+                for z in Z:
+                    h, m = self._relay(z, K, path)
+                    finals[m].append(h)
+                    targets[m].append(z)
+            for m in finals:
+                if finals[m]:
+                    self.readout[(path, m)] = _ridge(np.array(finals[m]), np.array(targets[m]))
+
+    def recover(self, z, K, path):
+        h, m = self._relay(z, K, path)
+        return _affine(self.readout[(path, m)], h.reshape(1, -1))[0]
+
+
+def _cos(a, b):
+    return float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-9))
+
+
+def demonstrate(hops=(1, 2, 4, 6, 8)) -> dict:
+    """Run the relay both ways and return meaning retained per hop count."""
+    d_meaning, vocab = 16, 256
+    link = _Conduit(d_meaning, dims=[32, 48], vocab=vocab)
+    link.fit(n_train=800, fit_hops=hops)
+    rng = np.random.default_rng(123)
+    test = rng.standard_normal((300, d_meaning))
+    out = {"latent": {}, "word": {}, "meaning_dim": d_meaning, "vocab": vocab, "hops": list(hops)}
+    for path in ("latent", "word"):
+        for K in hops:
+            out[path][K] = round(
+                float(np.mean([_cos(z, link.recover(z, K, path)) for z in test])), 3
+            )
+    return out

{deepparallel-0.3.1 → deepparallel-0.4.1}/deepparallel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.3.1
+Version: 0.4.1
 Summary: DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic.
 Author-email: Michael Crowe <michael@crowelogic.com>
 License: Apache-2.0
@@ -19,6 +19,8 @@ Requires-Dist: cryptography>=42.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: ruff>=0.6.0; extra == "dev"
+Provides-Extra: research
+Requires-Dist: numpy>=1.24; extra == "research"
 
 # DeepParallel
 
@@ -67,6 +69,7 @@ Set the backend env vars (a `.env` file in the working directory is loaded autom
     deepparallel run --yes "..."        # auto-approve tool actions
     deepparallel review <file|--diff>   # cross-model review as a CI gate (Pro)
     deepparallel audit <file>           # supply-chain gate: catch hallucinated deps (Pro)
+    deepparallel research conduit       # latent-relay research demo (needs [research] extra)
 
 ## Supply-chain gate
 

{deepparallel-0.3.1 → deepparallel-0.4.1}/deepparallel.egg-info/SOURCES.txt

@@ -18,6 +18,8 @@ deepparallel.egg-info/dependency_links.txt
 deepparallel.egg-info/entry_points.txt
 deepparallel.egg-info/requires.txt
 deepparallel.egg-info/top_level.txt
+deepparallel/research/__init__.py
+deepparallel/research/conduit.py
 deepparallel/tools/__init__.py
 deepparallel/tools/codeast.py
 deepparallel/tools/edit.py
@@ -39,6 +41,7 @@ tests/test_fusion.py
 tests/test_issuer_signer.py
 tests/test_licensing.py
 tests/test_renderer.py
+tests/test_research.py
 tests/test_supply_chain.py
 tests/test_tool_registry.py
 tests/test_tools_codeast.py

{deepparallel-0.3.1 → deepparallel-0.4.1}/deepparallel.egg-info/requires.txt

@@ -10,3 +10,6 @@ cryptography>=42.0.0
 [dev]
 pytest>=8.0.0
 ruff>=0.6.0
+
+[research]
+numpy>=1.24

{deepparallel-0.3.1 → deepparallel-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deepparallel"
-version = "0.3.1"
+version = "0.4.1"
 description = "DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic."
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -26,6 +26,7 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = ["pytest>=8.0.0", "ruff>=0.6.0"]
+research = ["numpy>=1.24"]
 
 [project.urls]
 Homepage = "https://crowelogic.com"

{deepparallel-0.3.1 → deepparallel-0.4.1}/tests/test_renderer.py

@@ -123,14 +123,27 @@ def test_rich_confirm_shows_detail():
     assert "added line" in out
 
 
-def test_rich_answer_stream_returns_text_and_prints_once():
+def test_rich_answer_stream_returns_text_and_renders_live_markdown():
     buf = io.StringIO()
     con = Console(no_color=True, width=80, file=buf, force_terminal=True, highlight=False)
     r = RichRenderer(console=con)
     full = r.answer_stream(iter(["Hel", "lo ", "world"]))
-    assert full == "Hello world"
-    # inline streaming prints the content exactly once (no transient-Live ghost)
-    assert buf.getvalue().count("world") == 1
+    out = buf.getvalue()
+    assert full == "Hello world"  # full text preserved for history
+    assert "Hello world" in out  # rendered in the live answer panel
+    assert "◆" in out and "answer" in out  # panel marker + title
+
+
+def test_rich_answer_stream_renders_markdown_formatting():
+    buf = io.StringIO()
+    con = Console(no_color=True, width=80, file=buf, force_terminal=True, highlight=False)
+    r = RichRenderer(console=con)
+    full = r.answer_stream(iter(["# Big\n\n", "body **bold**"]))
+    out = buf.getvalue()
+    assert full == "# Big\n\nbody **bold**"
+    # markdown is rendered, not shown raw: the heading hash is consumed
+    assert "Big" in out and "body" in out
+    assert "# Big" not in out
 
 
 def test_rich_answer_stream_empty_prints_nothing():
@@ -139,20 +152,29 @@ def test_rich_answer_stream_empty_prints_nothing():
     r = RichRenderer(console=con)
     full = r.answer_stream(iter([]))
     assert full == ""
-    assert buf.getvalue() == ""  # tool-only turns render no answer marker
+    assert buf.getvalue() == ""  # tool-only turns never start the live panel
 
 
-def test_rich_answer_stream_whitespace_leading_no_stray_marker():
+def test_rich_answer_stream_whitespace_leading_holds_panel():
     buf = io.StringIO()
     con = Console(no_color=True, width=80, file=buf, force_terminal=True, highlight=False)
     r = RichRenderer(console=con)
     full = r.answer_stream(iter(["\n", "  ", "\n", "Hello"]))
     out = buf.getvalue()
     assert full == "\n  \nHello"  # full text preserved for history
-    # marker appears exactly once and immediately precedes the visible text
-    assert out.count("◆") == 1
-    assert "◆ Hello" in out
-    assert "◆ \n" not in out and "◆  \n" not in out  # no stray marker on blank lines
+    assert "Hello" in out and "◆" in out
+
+
+def test_rich_answer_stream_inline_when_not_a_terminal():
+    # pipes / CI: raw inline streaming, no Live panel (no border characters)
+    buf = io.StringIO()
+    con = Console(no_color=True, width=80, file=buf, highlight=False)  # not a terminal
+    r = RichRenderer(console=con)
+    full = r.answer_stream(iter(["Hel", "lo"]))
+    out = buf.getvalue()
+    assert full == "Hello"
+    assert "Hello" in out
+    assert "─" not in out and "answer" not in out  # no panel chrome
 
 
 # ---------------------------------------------------------------- FakeRenderer

deepparallel-0.4.1/tests/test_research.py

@@ -0,0 +1,27 @@
+import pytest
+from click.testing import CliRunner
+
+from deepparallel.cli import main
+
+np = pytest.importorskip("numpy")  # research demos are an optional extra
+
+from deepparallel.research import conduit  # noqa: E402
+
+
+def test_demonstrate_latent_beats_word_at_every_hop():
+    r = conduit.demonstrate(hops=(1, 4, 8))
+    for k in (1, 4, 8):
+        assert r["latent"][k] > r["word"][k], f"latent should beat word at hop {k}"
+    assert r["latent"][1] > 0.7  # strong signal retained at one hop
+
+
+def test_demonstrate_word_channel_does_not_improve_with_depth():
+    r = conduit.demonstrate(hops=(1, 6))
+    assert r["word"][6] <= r["word"][1] + 0.05  # lossy re-serialization, no gain
+
+
+def test_research_conduit_command_runs_and_prints_table():
+    result = CliRunner().invoke(main, ["research", "conduit"])
+    assert result.exit_code == 0
+    assert "Conduit" in result.output
+    assert "latent relay" in result.output