feat(das-client): connect to a LIVE DAS over gRPC — version-matched AtomSpaceNode contract, ping -> PING (real end-to-end)

Author: MesTTo

packages/das-client/README.md

@@ -12,11 +12,28 @@ Distributed AtomSpace (DAS) as a pluggable `Space` backend for MeTTa TS.
 - **`das.metta`** — the vendored DAS module type declarations (`new-das!`, `das-evolution!`, …).
 - The bus command vocabulary (`BusCommand`) read from the Python `service_bus`.
 
-## The one remaining boundary (needs a live DAS to validate)
+## Validated against a live DAS ✅
 
-What's left is the **streaming pattern-matching choreography**: the proxy joins the network, issues a `PATTERN_MATCHING_QUERY` over `bus_command_proxy`, and assembles the streamed `query_answer_tokens_flow` — specifically the `ANSWER_BUNDLE`/`COUNT` token decoding into `QueryAnswer` bindings (`hyperon_das/service_clients/pattern_matching_query.py`).
+A real DAS cluster was stood up and the TypeScript client called it over gRPC end-to-end:
 
-This is intentionally **not** shipped as an unverified best-guess. Its exact wire format (token framing, answer encoding) can only be validated byte-for-byte against a running DAS (`das-toolbox`) or recorded real traffic — porting it blind would violate the project's correctness-first rule (don't ship sound-but-unverified code as if it works). The pieces it composes (gRPC transport, bus node, handle hashing, command vocabulary) are all real and tested above; finishing it is: stand up a DAS, capture/observe the answer-token frames, port the decoder, add the live differential test.
+```bash
+# 1.0.0 das-cli matches the released agent image; MongoDB 7.0 avoids the 8.x kernel guard.
+pip install -e das-toolbox/das-cli   # at tag 1.0.0
+das-cli config set                   # accept defaults
+das-cli db start                     # Redis :40020 + MongoDB :40021 (use mongo:7.0)
+das-cli metta load animals.metta
+das-cli ab start                     # Attention Broker :40001
+das-cli qa start                     # Query Agent :40002 (owns `pattern_matching_query`)
+
+DAS_LIVE=1 pnpm vitest run packages/das-client/src/live-das.test.ts
+#  LIVE DAS AtomSpaceNode.ping -> {"error":false,"msg":"PING"}
+```
+
+**Version-matching is the catch.** The released 1.0.0 Query Agent serves the `dasproto.AtomSpaceNode` service; `das-proto` HEAD later renamed it to `DistributedAlgorithmNode`. Calling HEAD's contract returns gRPC `UNIMPLEMENTED`; generating from the pre-rename `atom_space_node.proto` makes the call land (`ping` → `PING`). So the client carries both generated contracts and the live test uses the one the running agent actually serves.
+
+## The one remaining boundary (the query-token protocol)
+
+With gRPC connectivity to a live agent now proven, what's left is the **DAS query-token language + answer decode**: turn a MeTTa pattern into DAS query tokens (`LINK_TEMPLATE`/`NODE`/`VARIABLE` + handles), issue it via the proxy's `execute_message`, and decode the streamed `ANSWER_BUNDLE` tokens (`QueryAnswer.untokenize`, then resolve handles against the atomdb). The Python reference is `hyperon_das/service_clients/pattern_matching_query.py` + `query_answer.py`. This is now **unblocked** — a live DAS is the oracle — but it is a substantial, version-sensitive port (DAS's query path is itself marked *Under Construction* upstream), so it is built incrementally against the live agent rather than shipped as an unverified best-guess.
 
 **Node-only:** a participant hosts an inbound bus node, which a browser cannot do — the browser reaches DAS through [`@metta-ts/das-gateway`](../das-gateway).
 

packages/das-client/proto/atom_space_node.proto

@@ -0,0 +1,16 @@
+syntax = "proto3";
+import "common.proto";
+package dasproto;
+
+message MessageData {
+    string command = 1;
+    repeated string args = 2;
+    string sender = 3;
+    bool is_broadcast = 4;
+    repeated string visited_recipients = 5;
+}
+
+service AtomSpaceNode {
+    rpc ping (Empty) returns (Ack) {}
+    rpc execute_message (MessageData) returns (Empty) {}
+}

packages/das-client/src/gen/atom_space_node.ts

@@ -13,3 +13,4 @@
 export { type DasTransport, MockTransport } from "./transport";
 export { DasSpace } from "./das-space";
 export { computeHash, namedTypeHash, terminalHash, compositeHash, expressionHash } from "./handle";
+export { BusNode, BusCommand, type MessageHandler } from "./bus-node";

packages/das-client/src/gen/common.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from "vitest";
+import { credentials } from "@grpc/grpc-js";
+import { AtomSpaceNodeClient } from "./gen/atom_space_node";
+
+// Live integration: ping the running DAS Query Agent on :40002 over its actual (pre-rename)
+// AtomSpaceNode gRPC contract. Skipped unless a DAS is up (DAS_LIVE=1).
+const run = process.env.DAS_LIVE === "1" ? it : it.skip;
+describe("live DAS", () => {
+  run("pings the real Query Agent over gRPC", async () => {
+    const c = new AtomSpaceNodeClient("127.0.0.1:40002", credentials.createInsecure());
+    const ack = await new Promise<{ error: boolean; msg: string }>((res, rej) =>
+      c.ping({}, (e, a) => (e ? rej(e) : res(a))),
+    );
+    c.close();
+    console.log("LIVE DAS AtomSpaceNode.ping ->", JSON.stringify(ack));
+    expect(ack).toBeDefined();
+  });
+});