feat(itr): add FlatBuffers binary codec for ITR command protocol

Add zero-copy binary serialization for ToolRequest/ToolResponse using
FlatBuffers. The codec provides Marshal/Unmarshal methods on domain types
that produce/consume the same wire format across in-process channels,
Unix sockets, and WASM host calls.

- Update commands.fbs with CmdType enum, DAGNode/DAGPlan tables,
  ToolSearch/CodeExec commands
- Generate Go types in pkg/itr/itrfb/
- Implement bidirectional conversion in fb_codec.go

pkg/itr/commands.fbs

@@ -1,72 +1,96 @@
 // PicoClaw Isolated Tool Runtime — Command Protocol
-// Namespace: picoclaw.itr
+// Namespace: itrfb (FlatBuffers generated types)
 //
 // This schema defines the binary command protocol between the agent loop
 // and the SecureBus. All tool invocations, including RLM recursive
 // decomposition operations, are serialized using this schema.
 //
-// Generated Go code lives in commands_generated.go (committed).
+// To regenerate: flatc --go -o pkg/itr pkg/itr/commands.fbs
-// To regenerate: flatc --go --gen-mutable -o pkg/itr pkg/itr/commands.fbs
 //
 // FlatBuffers provides:
 //   - Zero-copy reads (no deserialization on the hot path)
 //   - Schema-enforced vocabulary (LLM cannot construct out-of-vocab requests)
 //   - Single binary format across all transports (channel, socket, WASM)
 
-namespace picoclaw.itr;
+namespace itrfb;
+
+// ── Command type discriminator ──────────────────────────────────────────────
+// Mirrors Go CommandType string constants as a numeric enum for wire encoding.
+
+enum CmdType : byte {
+  NONE       = 0,
+  Peek       = 1,
+  Grep       = 2,
+  Partition  = 3,
+  Recurse    = 4,
+  ToolExec   = 5,
+  ExecWasm   = 6,
+  Final      = 7,
+  ToolSearch = 8,
+  CodeExec   = 9,
+  DAGPlan    = 10
+}
 
 // ── RLM Decomposition Operations ────────────────────────────────────────────
 
-// Peek reads a byte range from the context rope.
 table Peek {
-  start:  uint64;  // byte offset
+  start:  uint64;
-  length: uint32;  // bytes to read (0 = to end)
+  length: uint32;
 }
 
-// Grep searches the context for a pattern.
 table Grep {
   pattern:          string (required);
   max_matches:      uint32 = 50;
   case_insensitive: bool   = false;
 }
 
-// Partition splits the context into k roughly-equal chunks.
 table Partition {
-  k:        uint32 = 4;     // number of partitions
+  k:        uint32 = 4;
-  method:   string = "uniform"; // "uniform" | "semantic"
+  method:   string;
-  overlap:  uint32 = 0;     // token overlap between partitions
+  overlap:  uint32 = 0;
-  semantic: bool   = false; // use semantic boundaries (sentence/paragraph)
+  semantic: bool   = false;
 }
 
-// Recurse spawns a sub-RLM call over a context partition.
 table Recurse {
-  sub_query:   string (required); // the question to answer over the partition
+  sub_query:   string (required);
-  context_key: string (required); // identifies which partition to use
+  context_key: string (required);
-  depth_hint:  uint8  = 3;        // max recursion depth
+  depth_hint:  uint8  = 3;
 }
 
-// ── Traditional Tool Execution ───────────────────────────────────────────────
+// ── Traditional Tool Execution ──────────────────────────────────────────────
 
-// ToolExec invokes a named tool with JSON-serialized arguments.
 table ToolExec {
   tool_name: string (required);
-  args_json: string (required);  // JSON object
+  args_json: string (required);
 }
 
-// ExecWasm runs a WASM module (Layer 5 — optional, wazero isolate).
 table ExecWasm {
-  module_key: string (required);  // key into the WASM module registry
+  module_key: string (required);
-  entry:      string (required);  // exported function name
+  entry:      string (required);
-  input_json: string;             // JSON input for the module
+  input_json: string;
 }
 
-// Final records the terminal answer from an RLM recursion.
 table Final {
   answer:   string (required);
-  var_name: string;  // optional variable name for multi-part answers
+  var_name: string;
 }
 
-// ── Envelope ─────────────────────────────────────────────────────────────────
+// ── Extended Commands ───────────────────────────────────────────────────────
+
+table ToolSearch {
+  query:       string (required);
+  max_results: uint8 = 10;
+}
+
+table CodeExec {
+  language: string (required);
+  code:     string (required);
+}
+
+// ── Payload Union ───────────────────────────────────────────────────────────
+// Used inside both ToolRequest (top-level) and DAGNode (nested).
+// DAGPlan is NOT in this union to avoid circular references;
+// it is a separate field on ToolRequest.
 
 union CommandPayload {
   Peek,
@@ -75,25 +99,47 @@ union CommandPayload {
   Recurse,
   ToolExec,
   ExecWasm,
-  Final
+  Final,
+  ToolSearch,
+  CodeExec
 }
 
-table ToolRequest {
+// ── DAG Structures ──────────────────────────────────────────────────────────
-  id:          string (required);  // UUIDv7 for correlation
+
+table DAGNode {
+  id:        string (required);
+  node_type: CmdType;
   payload:   CommandPayload;
-  timestamp:   uint64;             // Unix nanoseconds
+  depends_on: [string];
-  depth:       uint8  = 0;         // recursion depth (0 = top-level)
+}
-  session_key: string;             // opaque session/conversation identifier
+
-  tool_call_id: string;            // links back to LLM tool_call.id
+table DAGPlan {
+  nodes:        [DAGNode];
+  max_parallel: uint8  = 0;
+  token_budget: uint32 = 0;
+  joiner_query: string;
+}
+
+// ── Envelope ────────────────────────────────────────────────────────────────
+
+table ToolRequest {
+  id:           string (required);
+  cmd_type:     CmdType;
+  payload:      CommandPayload;
+  dag_plan:     DAGPlan;
+  timestamp:    uint64;
+  depth:        uint8  = 0;
+  session_key:  string;
+  tool_call_id: string;
 }
 
 table ToolResponse {
-  id:            string (required);  // mirrors request id
+  id:            string (required);
-  result:        string;             // JSON-serialized result
+  result:        string;
   is_error:      bool   = false;
-  leak_detected: bool   = false;     // set when Redactor found a match
+  leak_detected: bool   = false;
-  cost_tokens:   uint32 = 0;         // tokens consumed (RLM operations)
+  cost_tokens:   uint32 = 0;
-  redacted_keys: [string];           // keys that were redacted, for audit
+  redacted_keys: [string];
 }
 
 root_type ToolRequest;

pkg/itr/fb_codec.go

@@ -0,0 +1,575 @@
+package itr
+
+import (
+	"fmt"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+	"github.com/sipeed/picoclaw/pkg/itr/itrfb"
+)
+
+// ── Domain ↔ FlatBuffers enum mapping ───────────────────────────────────────
+
+var cmdTypeToFB = map[CommandType]itrfb.CmdType{
+	CmdPeek:       itrfb.CmdTypePeek,
+	CmdGrep:       itrfb.CmdTypeGrep,
+	CmdPartition:  itrfb.CmdTypePartition,
+	CmdRecurse:    itrfb.CmdTypeRecurse,
+	CmdToolExec:   itrfb.CmdTypeToolExec,
+	CmdExecWasm:   itrfb.CmdTypeExecWasm,
+	CmdFinal:      itrfb.CmdTypeFinal,
+	CmdToolSearch: itrfb.CmdTypeToolSearch,
+	CmdCodeExec:   itrfb.CmdTypeCodeExec,
+	CmdDAGPlan:    itrfb.CmdTypeDAGPlan,
+}
+
+var fbToCmdType = map[itrfb.CmdType]CommandType{
+	itrfb.CmdTypePeek:       CmdPeek,
+	itrfb.CmdTypeGrep:       CmdGrep,
+	itrfb.CmdTypePartition:  CmdPartition,
+	itrfb.CmdTypeRecurse:    CmdRecurse,
+	itrfb.CmdTypeToolExec:   CmdToolExec,
+	itrfb.CmdTypeExecWasm:   CmdExecWasm,
+	itrfb.CmdTypeFinal:      CmdFinal,
+	itrfb.CmdTypeToolSearch: CmdToolSearch,
+	itrfb.CmdTypeCodeExec:   CmdCodeExec,
+	itrfb.CmdTypeDAGPlan:    CmdDAGPlan,
+}
+
+// ── MarshalRequestFB ────────────────────────────────────────────────────────
+
+func MarshalRequestFB(r ToolRequest) ([]byte, error) {
+	b := flatbuffers.NewBuilder(512)
+
+	idOff := b.CreateString(r.ID)
+	skOff := b.CreateString(r.SessionKey)
+	tcOff := b.CreateString(r.ToolCallID)
+
+	fbCmdType, ok := cmdTypeToFB[r.Type]
+	if !ok {
+		return nil, fmt.Errorf("unknown command type: %q", r.Type)
+	}
+
+	if r.Type == CmdDAGPlan {
+		plan, ok := r.Payload.(DAGPlan)
+		if !ok {
+			return nil, fmt.Errorf("payload is not DAGPlan")
+		}
+		dagOff, err := buildDAGPlan(b, &plan)
+		if err != nil {
+			return nil, err
+		}
+		itrfb.ToolRequestStart(b)
+		itrfb.ToolRequestAddId(b, idOff)
+		itrfb.ToolRequestAddCmdType(b, fbCmdType)
+		itrfb.ToolRequestAddDagPlan(b, dagOff)
+		itrfb.ToolRequestAddTimestamp(b, uint64(r.Timestamp))
+		itrfb.ToolRequestAddDepth(b, r.Depth)
+		itrfb.ToolRequestAddSessionKey(b, skOff)
+		itrfb.ToolRequestAddToolCallId(b, tcOff)
+		reqOff := itrfb.ToolRequestEnd(b)
+		itrfb.FinishToolRequestBuffer(b, reqOff)
+		return b.FinishedBytes(), nil
+	}
+
+	payloadType, payloadOff, err := buildPayload(b, r.Type, r.Payload)
+	if err != nil {
+		return nil, err
+	}
+
+	itrfb.ToolRequestStart(b)
+	itrfb.ToolRequestAddId(b, idOff)
+	itrfb.ToolRequestAddCmdType(b, fbCmdType)
+	itrfb.ToolRequestAddPayloadType(b, payloadType)
+	itrfb.ToolRequestAddPayload(b, payloadOff)
+	itrfb.ToolRequestAddTimestamp(b, uint64(r.Timestamp))
+	itrfb.ToolRequestAddDepth(b, r.Depth)
+	itrfb.ToolRequestAddSessionKey(b, skOff)
+	itrfb.ToolRequestAddToolCallId(b, tcOff)
+	reqOff := itrfb.ToolRequestEnd(b)
+	itrfb.FinishToolRequestBuffer(b, reqOff)
+	return b.FinishedBytes(), nil
+}
+
+// ── UnmarshalRequestFB ──────────────────────────────────────────────────────
+
+func UnmarshalRequestFB(data []byte) (ToolRequest, error) {
+	fb := itrfb.GetRootAsToolRequest(data, 0)
+
+	ct, ok := fbToCmdType[fb.CmdType()]
+	if !ok {
+		return ToolRequest{}, fmt.Errorf("unknown FlatBuffers CmdType: %d", fb.CmdType())
+	}
+
+	req := ToolRequest{
+		ID:         string(fb.Id()),
+		Type:       ct,
+		Timestamp:  int64(fb.Timestamp()),
+		Depth:      fb.Depth(),
+		SessionKey: string(fb.SessionKey()),
+		ToolCallID: string(fb.ToolCallId()),
+	}
+
+	if ct == CmdDAGPlan {
+		fbPlan := fb.DagPlan(nil)
+		if fbPlan == nil {
+			return ToolRequest{}, fmt.Errorf("DAGPlan request missing dag_plan field")
+		}
+		plan, err := readDAGPlan(fbPlan)
+		if err != nil {
+			return ToolRequest{}, err
+		}
+		req.Payload = plan
+		return req, nil
+	}
+
+	payload, err := readPayload(fb.PayloadType(), fb)
+	if err != nil {
+		return ToolRequest{}, err
+	}
+	req.Payload = payload
+	return req, nil
+}
+
+// ── MarshalResponseFB ───────────────────────────────────────────────────────
+
+func MarshalResponseFB(r ToolResponse) ([]byte, error) {
+	b := flatbuffers.NewBuilder(256)
+
+	idOff := b.CreateString(r.ID)
+	resultOff := b.CreateString(r.Result)
+
+	var keysOff flatbuffers.UOffsetT
+	if len(r.RedactedKeys) > 0 {
+		keyOffsets := make([]flatbuffers.UOffsetT, len(r.RedactedKeys))
+		for i := len(r.RedactedKeys) - 1; i >= 0; i-- {
+			keyOffsets[i] = b.CreateString(r.RedactedKeys[i])
+		}
+		itrfb.ToolResponseStartRedactedKeysVector(b, len(r.RedactedKeys))
+		for i := len(keyOffsets) - 1; i >= 0; i-- {
+			b.PrependUOffsetT(keyOffsets[i])
+		}
+		keysOff = b.EndVector(len(r.RedactedKeys))
+	}
+
+	itrfb.ToolResponseStart(b)
+	itrfb.ToolResponseAddId(b, idOff)
+	itrfb.ToolResponseAddResult(b, resultOff)
+	itrfb.ToolResponseAddIsError(b, r.IsError)
+	itrfb.ToolResponseAddLeakDetected(b, r.LeakDetected)
+	itrfb.ToolResponseAddCostTokens(b, r.CostTokens)
+	if len(r.RedactedKeys) > 0 {
+		itrfb.ToolResponseAddRedactedKeys(b, keysOff)
+	}
+	respOff := itrfb.ToolResponseEnd(b)
+	itrfb.FinishToolResponseBuffer(b, respOff)
+	return b.FinishedBytes(), nil
+}
+
+// ── UnmarshalResponseFB ─────────────────────────────────────────────────────
+
+func UnmarshalResponseFB(data []byte) (ToolResponse, error) {
+	fb := itrfb.GetRootAsToolResponse(data, 0)
+
+	r := ToolResponse{
+		ID:           string(fb.Id()),
+		Result:       string(fb.Result()),
+		IsError:      fb.IsError(),
+		LeakDetected: fb.LeakDetected(),
+		CostTokens:   fb.CostTokens(),
+	}
+
+	n := fb.RedactedKeysLength()
+	if n > 0 {
+		r.RedactedKeys = make([]string, n)
+		for i := 0; i < n; i++ {
+			r.RedactedKeys[i] = string(fb.RedactedKeys(i))
+		}
+	}
+	return r, nil
+}
+
+// ── Payload builders ────────────────────────────────────────────────────────
+
+func buildPayload(b *flatbuffers.Builder, ct CommandType, payload interface{}) (itrfb.CommandPayload, flatbuffers.UOffsetT, error) {
+	switch ct {
+	case CmdPeek:
+		p, ok := payload.(Peek)
+		if !ok {
+			return 0, 0, fmt.Errorf("expected Peek payload, got %T", payload)
+		}
+		itrfb.PeekStart(b)
+		itrfb.PeekAddStart(b, p.Start)
+		itrfb.PeekAddLength(b, p.Length)
+		return itrfb.CommandPayloadPeek, itrfb.PeekEnd(b), nil
+
+	case CmdGrep:
+		p, ok := payload.(Grep)
+		if !ok {
+			return 0, 0, fmt.Errorf("expected Grep payload, got %T", payload)
+		}
+		pat := b.CreateString(p.Pattern)
+		itrfb.GrepStart(b)
+		itrfb.GrepAddPattern(b, pat)
+		itrfb.GrepAddMaxMatches(b, p.MaxMatches)
+		itrfb.GrepAddCaseInsensitive(b, p.CaseInsensitive)
+		return itrfb.CommandPayloadGrep, itrfb.GrepEnd(b), nil
+
+	case CmdPartition:
+		p, ok := payload.(Partition)
+		if !ok {
+			return 0, 0, fmt.Errorf("expected Partition payload, got %T", payload)
+		}
+		method := b.CreateString(p.Method)
+		itrfb.PartitionStart(b)
+		itrfb.PartitionAddK(b, p.K)
+		itrfb.PartitionAddMethod(b, method)
+		itrfb.PartitionAddOverlap(b, p.Overlap)
+		itrfb.PartitionAddSemantic(b, p.Semantic)
+		return itrfb.CommandPayloadPartition, itrfb.PartitionEnd(b), nil
+
+	case CmdRecurse:
+		p, ok := payload.(Recurse)
+		if !ok {
+			return 0, 0, fmt.Errorf("expected Recurse payload, got %T", payload)
+		}
+		sq := b.CreateString(p.SubQuery)
+		ck := b.CreateString(p.ContextKey)
+		itrfb.RecurseStart(b)
+		itrfb.RecurseAddSubQuery(b, sq)
+		itrfb.RecurseAddContextKey(b, ck)
+		itrfb.RecurseAddDepthHint(b, p.DepthHint)
+		return itrfb.CommandPayloadRecurse, itrfb.RecurseEnd(b), nil
+
+	case CmdToolExec:
+		p, ok := payload.(ToolExec)
+		if !ok {
+			return 0, 0, fmt.Errorf("expected ToolExec payload, got %T", payload)
+		}
+		tn := b.CreateString(p.ToolName)
+		aj := b.CreateString(p.ArgsJSON)
+		itrfb.ToolExecStart(b)
+		itrfb.ToolExecAddToolName(b, tn)
+		itrfb.ToolExecAddArgsJson(b, aj)
+		return itrfb.CommandPayloadToolExec, itrfb.ToolExecEnd(b), nil
+
+	case CmdExecWasm:
+		p, ok := payload.(ExecWasm)
+		if !ok {
+			return 0, 0, fmt.Errorf("expected ExecWasm payload, got %T", payload)
+		}
+		mk := b.CreateString(p.ModuleKey)
+		en := b.CreateString(p.Entry)
+		ij := b.CreateString(p.InputJSON)
+		itrfb.ExecWasmStart(b)
+		itrfb.ExecWasmAddModuleKey(b, mk)
+		itrfb.ExecWasmAddEntry(b, en)
+		itrfb.ExecWasmAddInputJson(b, ij)
+		return itrfb.CommandPayloadExecWasm, itrfb.ExecWasmEnd(b), nil
+
+	case CmdFinal:
+		p, ok := payload.(Final)
+		if !ok {
+			return 0, 0, fmt.Errorf("expected Final payload, got %T", payload)
+		}
+		ans := b.CreateString(p.Answer)
+		vn := b.CreateString(p.VarName)
+		itrfb.FinalStart(b)
+		itrfb.FinalAddAnswer(b, ans)
+		itrfb.FinalAddVarName(b, vn)
+		return itrfb.CommandPayloadFinal, itrfb.FinalEnd(b), nil
+
+	case CmdToolSearch:
+		p, ok := payload.(ToolSearch)
+		if !ok {
+			return 0, 0, fmt.Errorf("expected ToolSearch payload, got %T", payload)
+		}
+		q := b.CreateString(p.Query)
+		itrfb.ToolSearchStart(b)
+		itrfb.ToolSearchAddQuery(b, q)
+		itrfb.ToolSearchAddMaxResults(b, p.MaxResults)
+		return itrfb.CommandPayloadToolSearch, itrfb.ToolSearchEnd(b), nil
+
+	case CmdCodeExec:
+		p, ok := payload.(CodeExec)
+		if !ok {
+			return 0, 0, fmt.Errorf("expected CodeExec payload, got %T", payload)
+		}
+		lang := b.CreateString(p.Language)
+		code := b.CreateString(p.Code)
+		itrfb.CodeExecStart(b)
+		itrfb.CodeExecAddLanguage(b, lang)
+		itrfb.CodeExecAddCode(b, code)
+		return itrfb.CommandPayloadCodeExec, itrfb.CodeExecEnd(b), nil
+
+	default:
+		return 0, 0, fmt.Errorf("cannot build FlatBuffers payload for type %q", ct)
+	}
+}
+
+// ── Payload readers ─────────────────────────────────────────────────────────
+
+func readPayload(pt itrfb.CommandPayload, fb *itrfb.ToolRequest) (interface{}, error) {
+	var tbl flatbuffers.Table
+	if !fb.Payload(&tbl) {
+		return nil, fmt.Errorf("missing payload in FlatBuffers ToolRequest")
+	}
+
+	switch pt {
+	case itrfb.CommandPayloadPeek:
+		var p itrfb.Peek
+		p.Init(tbl.Bytes, tbl.Pos)
+		return Peek{Start: p.Start(), Length: p.Length()}, nil
+
+	case itrfb.CommandPayloadGrep:
+		var p itrfb.Grep
+		p.Init(tbl.Bytes, tbl.Pos)
+		return Grep{
+			Pattern:         string(p.Pattern()),
+			MaxMatches:      p.MaxMatches(),
+			CaseInsensitive: p.CaseInsensitive(),
+		}, nil
+
+	case itrfb.CommandPayloadPartition:
+		var p itrfb.Partition
+		p.Init(tbl.Bytes, tbl.Pos)
+		return Partition{
+			K:        p.K(),
+			Method:   string(p.Method()),
+			Overlap:  p.Overlap(),
+			Semantic: p.Semantic(),
+		}, nil
+
+	case itrfb.CommandPayloadRecurse:
+		var p itrfb.Recurse
+		p.Init(tbl.Bytes, tbl.Pos)
+		return Recurse{
+			SubQuery:   string(p.SubQuery()),
+			ContextKey: string(p.ContextKey()),
+			DepthHint:  p.DepthHint(),
+		}, nil
+
+	case itrfb.CommandPayloadToolExec:
+		var p itrfb.ToolExec
+		p.Init(tbl.Bytes, tbl.Pos)
+		return ToolExec{
+			ToolName: string(p.ToolName()),
+			ArgsJSON: string(p.ArgsJson()),
+		}, nil
+
+	case itrfb.CommandPayloadExecWasm:
+		var p itrfb.ExecWasm
+		p.Init(tbl.Bytes, tbl.Pos)
+		return ExecWasm{
+			ModuleKey: string(p.ModuleKey()),
+			Entry:     string(p.Entry()),
+			InputJSON: string(p.InputJson()),
+		}, nil
+
+	case itrfb.CommandPayloadFinal:
+		var p itrfb.Final
+		p.Init(tbl.Bytes, tbl.Pos)
+		return Final{
+			Answer:  string(p.Answer()),
+			VarName: string(p.VarName()),
+		}, nil
+
+	case itrfb.CommandPayloadToolSearch:
+		var p itrfb.ToolSearch
+		p.Init(tbl.Bytes, tbl.Pos)
+		return ToolSearch{
+			Query:      string(p.Query()),
+			MaxResults: p.MaxResults(),
+		}, nil
+
+	case itrfb.CommandPayloadCodeExec:
+		var p itrfb.CodeExec
+		p.Init(tbl.Bytes, tbl.Pos)
+		return CodeExec{
+			Language: string(p.Language()),
+			Code:     string(p.Code()),
+		}, nil
+
+	case itrfb.CommandPayloadNONE:
+		return nil, nil
+
+	default:
+		return nil, fmt.Errorf("unknown FlatBuffers payload type: %d", pt)
+	}
+}
+
+// ── DAGPlan builder/reader ──────────────────────────────────────────────────
+
+func buildDAGPlan(b *flatbuffers.Builder, plan *DAGPlan) (flatbuffers.UOffsetT, error) {
+	nodeOffsets := make([]flatbuffers.UOffsetT, len(plan.Nodes))
+	for i := len(plan.Nodes) - 1; i >= 0; i-- {
+		off, err := buildDAGNode(b, &plan.Nodes[i])
+		if err != nil {
+			return 0, fmt.Errorf("node %q: %w", plan.Nodes[i].ID, err)
+		}
+		nodeOffsets[i] = off
+	}
+
+	itrfb.DAGPlanStartNodesVector(b, len(nodeOffsets))
+	for i := len(nodeOffsets) - 1; i >= 0; i-- {
+		b.PrependUOffsetT(nodeOffsets[i])
+	}
+	nodesVec := b.EndVector(len(nodeOffsets))
+
+	jq := b.CreateString(plan.JoinerQuery)
+
+	itrfb.DAGPlanStart(b)
+	itrfb.DAGPlanAddNodes(b, nodesVec)
+	itrfb.DAGPlanAddMaxParallel(b, plan.MaxParallel)
+	itrfb.DAGPlanAddTokenBudget(b, plan.TokenBudget)
+	itrfb.DAGPlanAddJoinerQuery(b, jq)
+	return itrfb.DAGPlanEnd(b), nil
+}
+
+func buildDAGNode(b *flatbuffers.Builder, node *DAGNode) (flatbuffers.UOffsetT, error) {
+	idOff := b.CreateString(node.ID)
+
+	depOffsets := make([]flatbuffers.UOffsetT, len(node.DependsOn))
+	for i := len(node.DependsOn) - 1; i >= 0; i-- {
+		depOffsets[i] = b.CreateString(node.DependsOn[i])
+	}
+	var depsVec flatbuffers.UOffsetT
+	if len(depOffsets) > 0 {
+		itrfb.DAGNodeStartDependsOnVector(b, len(depOffsets))
+		for i := len(depOffsets) - 1; i >= 0; i-- {
+			b.PrependUOffsetT(depOffsets[i])
+		}
+		depsVec = b.EndVector(len(depOffsets))
+	}
+
+	fbNodeType, ok := cmdTypeToFB[node.Type]
+	if !ok {
+		return 0, fmt.Errorf("unknown node type: %q", node.Type)
+	}
+
+	payloadType, payloadOff, err := buildPayload(b, node.Type, node.Payload)
+	if err != nil {
+		return 0, err
+	}
+
+	itrfb.DAGNodeStart(b)
+	itrfb.DAGNodeAddId(b, idOff)
+	itrfb.DAGNodeAddNodeType(b, fbNodeType)
+	itrfb.DAGNodeAddPayloadType(b, payloadType)
+	itrfb.DAGNodeAddPayload(b, payloadOff)
+	if len(depOffsets) > 0 {
+		itrfb.DAGNodeAddDependsOn(b, depsVec)
+	}
+	return itrfb.DAGNodeEnd(b), nil
+}
+
+func readDAGPlan(fb *itrfb.DAGPlan) (DAGPlan, error) {
+	plan := DAGPlan{
+		MaxParallel: fb.MaxParallel(),
+		TokenBudget: fb.TokenBudget(),
+		JoinerQuery: string(fb.JoinerQuery()),
+	}
+
+	n := fb.NodesLength()
+	if n > 0 {
+		plan.Nodes = make([]DAGNode, n)
+		for i := 0; i < n; i++ {
+			var fbNode itrfb.DAGNode
+			if !fb.Nodes(&fbNode, i) {
+				return DAGPlan{}, fmt.Errorf("failed to read DAG node at index %d", i)
+			}
+			node, err := readDAGNode(&fbNode)
+			if err != nil {
+				return DAGPlan{}, fmt.Errorf("node %d: %w", i, err)
+			}
+			plan.Nodes[i] = node
+		}
+	}
+	return plan, nil
+}
+
+func readDAGNode(fb *itrfb.DAGNode) (DAGNode, error) {
+	ct, ok := fbToCmdType[itrfb.CmdType(fb.NodeType())]
+	if !ok {
+		return DAGNode{}, fmt.Errorf("unknown FlatBuffers node type: %d", fb.NodeType())
+	}
+
+	node := DAGNode{
+		ID:   string(fb.Id()),
+		Type: ct,
+	}
+
+	ndeps := fb.DependsOnLength()
+	if ndeps > 0 {
+		node.DependsOn = make([]string, ndeps)
+		for i := 0; i < ndeps; i++ {
+			node.DependsOn[i] = string(fb.DependsOn(i))
+		}
+	}
+
+	payload, err := readNodePayload(fb.PayloadType(), fb)
+	if err != nil {
+		return DAGNode{}, err
+	}
+	node.Payload = payload
+	return node, nil
+}
+
+func readNodePayload(pt itrfb.CommandPayload, fb *itrfb.DAGNode) (interface{}, error) {
+	var tbl flatbuffers.Table
+	if !fb.Payload(&tbl) {
+		return nil, nil
+	}
+
+	switch pt {
+	case itrfb.CommandPayloadPeek:
+		var p itrfb.Peek
+		p.Init(tbl.Bytes, tbl.Pos)
+		return Peek{Start: p.Start(), Length: p.Length()}, nil
+
+	case itrfb.CommandPayloadGrep:
+		var p itrfb.Grep
+		p.Init(tbl.Bytes, tbl.Pos)
+		return Grep{Pattern: string(p.Pattern()), MaxMatches: p.MaxMatches(), CaseInsensitive: p.CaseInsensitive()}, nil
+
+	case itrfb.CommandPayloadPartition:
+		var p itrfb.Partition
+		p.Init(tbl.Bytes, tbl.Pos)
+		return Partition{K: p.K(), Method: string(p.Method()), Overlap: p.Overlap(), Semantic: p.Semantic()}, nil
+
+	case itrfb.CommandPayloadRecurse:
+		var p itrfb.Recurse
+		p.Init(tbl.Bytes, tbl.Pos)
+		return Recurse{SubQuery: string(p.SubQuery()), ContextKey: string(p.ContextKey()), DepthHint: p.DepthHint()}, nil
+
+	case itrfb.CommandPayloadToolExec:
+		var p itrfb.ToolExec
+		p.Init(tbl.Bytes, tbl.Pos)
+		return ToolExec{ToolName: string(p.ToolName()), ArgsJSON: string(p.ArgsJson())}, nil
+
+	case itrfb.CommandPayloadExecWasm:
+		var p itrfb.ExecWasm
+		p.Init(tbl.Bytes, tbl.Pos)
+		return ExecWasm{ModuleKey: string(p.ModuleKey()), Entry: string(p.Entry()), InputJSON: string(p.InputJson())}, nil
+
+	case itrfb.CommandPayloadFinal:
+		var p itrfb.Final
+		p.Init(tbl.Bytes, tbl.Pos)
+		return Final{Answer: string(p.Answer()), VarName: string(p.VarName())}, nil
+
+	case itrfb.CommandPayloadToolSearch:
+		var p itrfb.ToolSearch
+		p.Init(tbl.Bytes, tbl.Pos)
+		return ToolSearch{Query: string(p.Query()), MaxResults: p.MaxResults()}, nil
+
+	case itrfb.CommandPayloadCodeExec:
+		var p itrfb.CodeExec
+		p.Init(tbl.Bytes, tbl.Pos)
+		return CodeExec{Language: string(p.Language()), Code: string(p.Code())}, nil
+
+	case itrfb.CommandPayloadNONE:
+		return nil, nil
+
+	default:
+		return nil, fmt.Errorf("unknown FlatBuffers node payload type: %d", pt)
+	}
+}

pkg/itr/fb_codec_test.go

@@ -0,0 +1,285 @@
+package itr_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/sipeed/picoclaw/pkg/itr"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFBCodec_RequestRoundtrip_Peek(t *testing.T) {
+	orig := itr.NewPeekRequest("req-1", "sess-A", 2, 1024, 4096)
+
+	data, err := itr.MarshalRequestFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalRequestFB(data)
+	require.NoError(t, err)
+
+	assert.Equal(t, orig.ID, got.ID)
+	assert.Equal(t, orig.Type, got.Type)
+	assert.Equal(t, orig.Depth, got.Depth)
+	assert.Equal(t, orig.SessionKey, got.SessionKey)
+	origP, ok := orig.Payload.(itr.Peek)
+	require.True(t, ok, "orig payload should be Peek")
+	gotP, ok := got.Payload.(itr.Peek)
+	require.True(t, ok, "got payload should be Peek")
+	assert.Equal(t, origP, gotP)
+}
+
+func TestFBCodec_RequestRoundtrip_Grep(t *testing.T) {
+	orig := itr.NewGrepRequest("req-2", "sess-B", 1, "error.*fatal", 25, true)
+
+	data, err := itr.MarshalRequestFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalRequestFB(data)
+	require.NoError(t, err)
+
+	assert.Equal(t, orig.Type, got.Type)
+	p, ok := got.Payload.(itr.Grep)
+	require.True(t, ok, "payload should be Grep")
+	assert.Equal(t, "error.*fatal", p.Pattern)
+	assert.Equal(t, uint32(25), p.MaxMatches)
+	assert.True(t, p.CaseInsensitive)
+}
+
+func TestFBCodec_RequestRoundtrip_Partition(t *testing.T) {
+	orig := itr.NewPartitionRequest("req-3", "sess-C", 0, 8, "semantic", 100, true)
+
+	data, err := itr.MarshalRequestFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalRequestFB(data)
+	require.NoError(t, err)
+
+	p, ok := got.Payload.(itr.Partition)
+	require.True(t, ok, "payload should be Partition")
+	assert.Equal(t, uint32(8), p.K)
+	assert.Equal(t, "semantic", p.Method)
+	assert.Equal(t, uint32(100), p.Overlap)
+	assert.True(t, p.Semantic)
+}
+
+func TestFBCodec_RequestRoundtrip_Recurse(t *testing.T) {
+	orig := itr.NewRecurseRequest("req-4", "sess-D", 3, "summarize this", "ctx-key-7", 5)
+
+	data, err := itr.MarshalRequestFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalRequestFB(data)
+	require.NoError(t, err)
+
+	p, ok := got.Payload.(itr.Recurse)
+	require.True(t, ok, "payload should be Recurse")
+	assert.Equal(t, "summarize this", p.SubQuery)
+	assert.Equal(t, "ctx-key-7", p.ContextKey)
+	assert.Equal(t, uint8(5), p.DepthHint)
+}
+
+func TestFBCodec_RequestRoundtrip_ToolExec(t *testing.T) {
+	orig := itr.NewToolExecRequest("req-5", "sess-E", "tc-1", "read_file", `{"path":"/etc/hosts"}`)
+
+	data, err := itr.MarshalRequestFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalRequestFB(data)
+	require.NoError(t, err)
+
+	p, ok := got.Payload.(itr.ToolExec)
+	require.True(t, ok, "payload should be ToolExec")
+	assert.Equal(t, "read_file", p.ToolName)
+	assert.Equal(t, `{"path":"/etc/hosts"}`, p.ArgsJSON)
+	assert.Equal(t, "tc-1", got.ToolCallID)
+}
+
+func TestFBCodec_RequestRoundtrip_ExecWasm(t *testing.T) {
+	orig := itr.ToolRequest{
+		ID:         "req-6",
+		Type:       itr.CmdExecWasm,
+		Payload:    itr.ExecWasm{ModuleKey: "mod-1", Entry: "main", InputJSON: `{"x":1}`},
+		Timestamp:  time.Now().UnixNano(),
+		SessionKey: "sess-F",
+	}
+
+	data, err := itr.MarshalRequestFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalRequestFB(data)
+	require.NoError(t, err)
+
+	p, ok := got.Payload.(itr.ExecWasm)
+	require.True(t, ok, "payload should be ExecWasm")
+	assert.Equal(t, "mod-1", p.ModuleKey)
+	assert.Equal(t, "main", p.Entry)
+	assert.Equal(t, `{"x":1}`, p.InputJSON)
+}
+
+func TestFBCodec_RequestRoundtrip_Final(t *testing.T) {
+	orig := itr.NewFinalRequest("req-7", "sess-G", 2, "The answer is 42", "ans_var")
+
+	data, err := itr.MarshalRequestFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalRequestFB(data)
+	require.NoError(t, err)
+
+	p, ok := got.Payload.(itr.Final)
+	require.True(t, ok, "payload should be Final")
+	assert.Equal(t, "The answer is 42", p.Answer)
+	assert.Equal(t, "ans_var", p.VarName)
+}
+
+func TestFBCodec_RequestRoundtrip_ToolSearch(t *testing.T) {
+	orig := itr.NewToolSearchRequest("req-8", "sess-H", "find file tools", 5)
+
+	data, err := itr.MarshalRequestFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalRequestFB(data)
+	require.NoError(t, err)
+
+	p, ok := got.Payload.(itr.ToolSearch)
+	require.True(t, ok, "payload should be ToolSearch")
+	assert.Equal(t, "find file tools", p.Query)
+	assert.Equal(t, uint8(5), p.MaxResults)
+}
+
+func TestFBCodec_RequestRoundtrip_CodeExec(t *testing.T) {
+	orig := itr.NewCodeExecRequest("req-9", "sess-I", "console.log('hi')", "javascript")
+
+	data, err := itr.MarshalRequestFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalRequestFB(data)
+	require.NoError(t, err)
+
+	p, ok := got.Payload.(itr.CodeExec)
+	require.True(t, ok, "payload should be CodeExec")
+	assert.Equal(t, "console.log('hi')", p.Code)
+	assert.Equal(t, "javascript", p.Language)
+}
+
+func TestFBCodec_RequestRoundtrip_DAGPlan(t *testing.T) {
+	plan := itr.DAGPlan{
+		Nodes: []itr.DAGNode{
+			{
+				ID:      "a",
+				Type:    itr.CmdToolExec,
+				Payload: itr.ToolExec{ToolName: "read_file", ArgsJSON: `{"path":"x.txt"}`},
+			},
+			{
+				ID:        "b",
+				Type:      itr.CmdToolSearch,
+				Payload:   itr.ToolSearch{Query: "search tools", MaxResults: 3},
+				DependsOn: []string{"a"},
+			},
+		},
+		MaxParallel: 4,
+		TokenBudget: 10000,
+		JoinerQuery: "Summarize the results",
+	}
+	orig := itr.NewDAGPlanRequest("req-10", "sess-J", plan)
+
+	data, err := itr.MarshalRequestFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalRequestFB(data)
+	require.NoError(t, err)
+
+	assert.Equal(t, itr.CmdDAGPlan, got.Type)
+
+	gotPlan, ok := got.Payload.(itr.DAGPlan)
+	require.True(t, ok)
+
+	assert.Equal(t, uint8(4), gotPlan.MaxParallel)
+	assert.Equal(t, uint32(10000), gotPlan.TokenBudget)
+	assert.Equal(t, "Summarize the results", gotPlan.JoinerQuery)
+	require.Len(t, gotPlan.Nodes, 2)
+
+	nodeA := gotPlan.Nodes[0]
+	assert.Equal(t, "a", nodeA.ID)
+	assert.Equal(t, itr.CmdToolExec, nodeA.Type)
+	te, ok := nodeA.Payload.(itr.ToolExec)
+	require.True(t, ok)
+	assert.Equal(t, "read_file", te.ToolName)
+	assert.Equal(t, `{"path":"x.txt"}`, te.ArgsJSON)
+
+	nodeB := gotPlan.Nodes[1]
+	assert.Equal(t, "b", nodeB.ID)
+	assert.Equal(t, itr.CmdToolSearch, nodeB.Type)
+	ts, ok := nodeB.Payload.(itr.ToolSearch)
+	require.True(t, ok)
+	assert.Equal(t, "search tools", ts.Query)
+	assert.Equal(t, uint8(3), ts.MaxResults)
+	assert.Equal(t, []string{"a"}, nodeB.DependsOn)
+}
+
+func TestFBCodec_ResponseRoundtrip_Success(t *testing.T) {
+	orig := itr.NewSuccessResponse("resp-1", "file contents here", 150)
+
+	data, err := itr.MarshalResponseFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalResponseFB(data)
+	require.NoError(t, err)
+
+	assert.Equal(t, "resp-1", got.ID)
+	assert.Equal(t, "file contents here", got.Result)
+	assert.False(t, got.IsError)
+	assert.Equal(t, uint32(150), got.CostTokens)
+}
+
+func TestFBCodec_ResponseRoundtrip_Error(t *testing.T) {
+	orig := itr.NewErrorResponse("resp-2", "tool not found")
+
+	data, err := itr.MarshalResponseFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalResponseFB(data)
+	require.NoError(t, err)
+
+	assert.True(t, got.IsError)
+	assert.Equal(t, "tool not found", got.Result)
+}
+
+func TestFBCodec_ResponseRoundtrip_Leak(t *testing.T) {
+	orig := itr.NewLeakResponse("resp-3", "redacted output", []string{"api_key", "password"})
+
+	data, err := itr.MarshalResponseFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalResponseFB(data)
+	require.NoError(t, err)
+
+	assert.True(t, got.LeakDetected)
+	assert.Equal(t, []string{"api_key", "password"}, got.RedactedKeys)
+}
+
+func TestFBCodec_TimestampPreserved(t *testing.T) {
+	ts := time.Now().UnixNano()
+	orig := itr.ToolRequest{
+		ID:        "ts-test",
+		Type:      itr.CmdPeek,
+		Payload:   itr.Peek{Start: 0, Length: 10},
+		Timestamp: ts,
+	}
+
+	data, err := itr.MarshalRequestFB(orig)
+	require.NoError(t, err)
+
+	got, err := itr.UnmarshalRequestFB(data)
+	require.NoError(t, err)
+
+	assert.Equal(t, ts, got.Timestamp)
+}
+
+func TestFBCodec_UnknownCommandType(t *testing.T) {
+	_, err := itr.MarshalRequestFB(itr.ToolRequest{
+		ID:   "bad",
+		Type: itr.CommandType("nonexistent"),
+	})
+	assert.Error(t, err)
+}

pkg/itr/itrfb/CmdType.go

@@ -0,0 +1,56 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import "strconv"
+
+type CmdType int8
+
+const (
+	CmdTypeNONE       CmdType = 0
+	CmdTypePeek       CmdType = 1
+	CmdTypeGrep       CmdType = 2
+	CmdTypePartition  CmdType = 3
+	CmdTypeRecurse    CmdType = 4
+	CmdTypeToolExec   CmdType = 5
+	CmdTypeExecWasm   CmdType = 6
+	CmdTypeFinal      CmdType = 7
+	CmdTypeToolSearch CmdType = 8
+	CmdTypeCodeExec   CmdType = 9
+	CmdTypeDAGPlan    CmdType = 10
+)
+
+var EnumNamesCmdType = map[CmdType]string{
+	CmdTypeNONE:       "NONE",
+	CmdTypePeek:       "Peek",
+	CmdTypeGrep:       "Grep",
+	CmdTypePartition:  "Partition",
+	CmdTypeRecurse:    "Recurse",
+	CmdTypeToolExec:   "ToolExec",
+	CmdTypeExecWasm:   "ExecWasm",
+	CmdTypeFinal:      "Final",
+	CmdTypeToolSearch: "ToolSearch",
+	CmdTypeCodeExec:   "CodeExec",
+	CmdTypeDAGPlan:    "DAGPlan",
+}
+
+var EnumValuesCmdType = map[string]CmdType{
+	"NONE":       CmdTypeNONE,
+	"Peek":       CmdTypePeek,
+	"Grep":       CmdTypeGrep,
+	"Partition":  CmdTypePartition,
+	"Recurse":    CmdTypeRecurse,
+	"ToolExec":   CmdTypeToolExec,
+	"ExecWasm":   CmdTypeExecWasm,
+	"Final":      CmdTypeFinal,
+	"ToolSearch": CmdTypeToolSearch,
+	"CodeExec":   CmdTypeCodeExec,
+	"DAGPlan":    CmdTypeDAGPlan,
+}
+
+func (v CmdType) String() string {
+	if s, ok := EnumNamesCmdType[v]; ok {
+		return s
+	}
+	return "CmdType(" + strconv.FormatInt(int64(v), 10) + ")"
+}

pkg/itr/itrfb/CodeExec.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CodeExec struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCodeExec(buf []byte, offset flatbuffers.UOffsetT) *CodeExec {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CodeExec{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCodeExecBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCodeExec(buf []byte, offset flatbuffers.UOffsetT) *CodeExec {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CodeExec{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCodeExecBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CodeExec) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CodeExec) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CodeExec) Language() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CodeExec) Code() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func CodeExecStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func CodeExecAddLanguage(builder *flatbuffers.Builder, language flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(language), 0)
+}
+func CodeExecAddCode(builder *flatbuffers.Builder, code flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(code), 0)
+}
+func CodeExecEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/itr/itrfb/CommandPayload.go

@@ -0,0 +1,53 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import "strconv"
+
+type CommandPayload byte
+
+const (
+	CommandPayloadNONE       CommandPayload = 0
+	CommandPayloadPeek       CommandPayload = 1
+	CommandPayloadGrep       CommandPayload = 2
+	CommandPayloadPartition  CommandPayload = 3
+	CommandPayloadRecurse    CommandPayload = 4
+	CommandPayloadToolExec   CommandPayload = 5
+	CommandPayloadExecWasm   CommandPayload = 6
+	CommandPayloadFinal      CommandPayload = 7
+	CommandPayloadToolSearch CommandPayload = 8
+	CommandPayloadCodeExec   CommandPayload = 9
+)
+
+var EnumNamesCommandPayload = map[CommandPayload]string{
+	CommandPayloadNONE:       "NONE",
+	CommandPayloadPeek:       "Peek",
+	CommandPayloadGrep:       "Grep",
+	CommandPayloadPartition:  "Partition",
+	CommandPayloadRecurse:    "Recurse",
+	CommandPayloadToolExec:   "ToolExec",
+	CommandPayloadExecWasm:   "ExecWasm",
+	CommandPayloadFinal:      "Final",
+	CommandPayloadToolSearch: "ToolSearch",
+	CommandPayloadCodeExec:   "CodeExec",
+}
+
+var EnumValuesCommandPayload = map[string]CommandPayload{
+	"NONE":       CommandPayloadNONE,
+	"Peek":       CommandPayloadPeek,
+	"Grep":       CommandPayloadGrep,
+	"Partition":  CommandPayloadPartition,
+	"Recurse":    CommandPayloadRecurse,
+	"ToolExec":   CommandPayloadToolExec,
+	"ExecWasm":   CommandPayloadExecWasm,
+	"Final":      CommandPayloadFinal,
+	"ToolSearch": CommandPayloadToolSearch,
+	"CodeExec":   CommandPayloadCodeExec,
+}
+
+func (v CommandPayload) String() string {
+	if s, ok := EnumNamesCommandPayload[v]; ok {
+		return s
+	}
+	return "CommandPayload(" + strconv.FormatInt(int64(v), 10) + ")"
+}

pkg/itr/itrfb/DAGNode.go

@@ -0,0 +1,125 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type DAGNode struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsDAGNode(buf []byte, offset flatbuffers.UOffsetT) *DAGNode {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &DAGNode{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishDAGNodeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsDAGNode(buf []byte, offset flatbuffers.UOffsetT) *DAGNode {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &DAGNode{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedDAGNodeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *DAGNode) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *DAGNode) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *DAGNode) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *DAGNode) NodeType() CmdType {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return CmdType(rcv._tab.GetInt8(o + rcv._tab.Pos))
+	}
+	return 0
+}
+
+func (rcv *DAGNode) MutateNodeType(n CmdType) bool {
+	return rcv._tab.MutateInt8Slot(6, int8(n))
+}
+
+func (rcv *DAGNode) PayloadType() CommandPayload {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return CommandPayload(rcv._tab.GetByte(o + rcv._tab.Pos))
+	}
+	return 0
+}
+
+func (rcv *DAGNode) MutatePayloadType(n CommandPayload) bool {
+	return rcv._tab.MutateByteSlot(8, byte(n))
+}
+
+func (rcv *DAGNode) Payload(obj *flatbuffers.Table) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		rcv._tab.Union(obj, o)
+		return true
+	}
+	return false
+}
+
+func (rcv *DAGNode) DependsOn(j int) []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		a := rcv._tab.Vector(o)
+		return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
+	}
+	return nil
+}
+
+func (rcv *DAGNode) DependsOnLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func DAGNodeStart(builder *flatbuffers.Builder) {
+	builder.StartObject(5)
+}
+func DAGNodeAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func DAGNodeAddNodeType(builder *flatbuffers.Builder, nodeType CmdType) {
+	builder.PrependInt8Slot(1, int8(nodeType), 0)
+}
+func DAGNodeAddPayloadType(builder *flatbuffers.Builder, payloadType CommandPayload) {
+	builder.PrependByteSlot(2, byte(payloadType), 0)
+}
+func DAGNodeAddPayload(builder *flatbuffers.Builder, payload flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(payload), 0)
+}
+func DAGNodeAddDependsOn(builder *flatbuffers.Builder, dependsOn flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(dependsOn), 0)
+}
+func DAGNodeStartDependsOnVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func DAGNodeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/itr/itrfb/DAGPlan.go

@@ -0,0 +1,116 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type DAGPlan struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsDAGPlan(buf []byte, offset flatbuffers.UOffsetT) *DAGPlan {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &DAGPlan{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishDAGPlanBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsDAGPlan(buf []byte, offset flatbuffers.UOffsetT) *DAGPlan {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &DAGPlan{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedDAGPlanBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *DAGPlan) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *DAGPlan) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *DAGPlan) Nodes(obj *DAGNode, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *DAGPlan) NodesLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *DAGPlan) MaxParallel() byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetByte(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *DAGPlan) MutateMaxParallel(n byte) bool {
+	return rcv._tab.MutateByteSlot(6, n)
+}
+
+func (rcv *DAGPlan) TokenBudget() uint32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetUint32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *DAGPlan) MutateTokenBudget(n uint32) bool {
+	return rcv._tab.MutateUint32Slot(8, n)
+}
+
+func (rcv *DAGPlan) JoinerQuery() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func DAGPlanStart(builder *flatbuffers.Builder) {
+	builder.StartObject(4)
+}
+func DAGPlanAddNodes(builder *flatbuffers.Builder, nodes flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(nodes), 0)
+}
+func DAGPlanStartNodesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func DAGPlanAddMaxParallel(builder *flatbuffers.Builder, maxParallel byte) {
+	builder.PrependByteSlot(1, maxParallel, 0)
+}
+func DAGPlanAddTokenBudget(builder *flatbuffers.Builder, tokenBudget uint32) {
+	builder.PrependUint32Slot(2, tokenBudget, 0)
+}
+func DAGPlanAddJoinerQuery(builder *flatbuffers.Builder, joinerQuery flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(joinerQuery), 0)
+}
+func DAGPlanEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/itr/itrfb/ExecWasm.go

@@ -0,0 +1,82 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ExecWasm struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsExecWasm(buf []byte, offset flatbuffers.UOffsetT) *ExecWasm {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ExecWasm{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishExecWasmBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsExecWasm(buf []byte, offset flatbuffers.UOffsetT) *ExecWasm {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ExecWasm{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedExecWasmBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ExecWasm) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ExecWasm) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ExecWasm) ModuleKey() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ExecWasm) Entry() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ExecWasm) InputJson() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func ExecWasmStart(builder *flatbuffers.Builder) {
+	builder.StartObject(3)
+}
+func ExecWasmAddModuleKey(builder *flatbuffers.Builder, moduleKey flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(moduleKey), 0)
+}
+func ExecWasmAddEntry(builder *flatbuffers.Builder, entry flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(entry), 0)
+}
+func ExecWasmAddInputJson(builder *flatbuffers.Builder, inputJson flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(inputJson), 0)
+}
+func ExecWasmEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/itr/itrfb/Final.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Final struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsFinal(buf []byte, offset flatbuffers.UOffsetT) *Final {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Final{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishFinalBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsFinal(buf []byte, offset flatbuffers.UOffsetT) *Final {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Final{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedFinalBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Final) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Final) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Final) Answer() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Final) VarName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func FinalStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func FinalAddAnswer(builder *flatbuffers.Builder, answer flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(answer), 0)
+}
+func FinalAddVarName(builder *flatbuffers.Builder, varName flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(varName), 0)
+}
+func FinalEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/itr/itrfb/Grep.go

@@ -0,0 +1,90 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Grep struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsGrep(buf []byte, offset flatbuffers.UOffsetT) *Grep {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Grep{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishGrepBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsGrep(buf []byte, offset flatbuffers.UOffsetT) *Grep {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Grep{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedGrepBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Grep) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Grep) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Grep) Pattern() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Grep) MaxMatches() uint32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetUint32(o + rcv._tab.Pos)
+	}
+	return 50
+}
+
+func (rcv *Grep) MutateMaxMatches(n uint32) bool {
+	return rcv._tab.MutateUint32Slot(6, n)
+}
+
+func (rcv *Grep) CaseInsensitive() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *Grep) MutateCaseInsensitive(n bool) bool {
+	return rcv._tab.MutateBoolSlot(8, n)
+}
+
+func GrepStart(builder *flatbuffers.Builder) {
+	builder.StartObject(3)
+}
+func GrepAddPattern(builder *flatbuffers.Builder, pattern flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(pattern), 0)
+}
+func GrepAddMaxMatches(builder *flatbuffers.Builder, maxMatches uint32) {
+	builder.PrependUint32Slot(1, maxMatches, 50)
+}
+func GrepAddCaseInsensitive(builder *flatbuffers.Builder, caseInsensitive bool) {
+	builder.PrependBoolSlot(2, caseInsensitive, false)
+}
+func GrepEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/itr/itrfb/Partition.go

@@ -0,0 +1,105 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Partition struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsPartition(buf []byte, offset flatbuffers.UOffsetT) *Partition {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Partition{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishPartitionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsPartition(buf []byte, offset flatbuffers.UOffsetT) *Partition {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Partition{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedPartitionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Partition) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Partition) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Partition) K() uint32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetUint32(o + rcv._tab.Pos)
+	}
+	return 4
+}
+
+func (rcv *Partition) MutateK(n uint32) bool {
+	return rcv._tab.MutateUint32Slot(4, n)
+}
+
+func (rcv *Partition) Method() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Partition) Overlap() uint32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetUint32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Partition) MutateOverlap(n uint32) bool {
+	return rcv._tab.MutateUint32Slot(8, n)
+}
+
+func (rcv *Partition) Semantic() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *Partition) MutateSemantic(n bool) bool {
+	return rcv._tab.MutateBoolSlot(10, n)
+}
+
+func PartitionStart(builder *flatbuffers.Builder) {
+	builder.StartObject(4)
+}
+func PartitionAddK(builder *flatbuffers.Builder, k uint32) {
+	builder.PrependUint32Slot(0, k, 4)
+}
+func PartitionAddMethod(builder *flatbuffers.Builder, method flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(method), 0)
+}
+func PartitionAddOverlap(builder *flatbuffers.Builder, overlap uint32) {
+	builder.PrependUint32Slot(2, overlap, 0)
+}
+func PartitionAddSemantic(builder *flatbuffers.Builder, semantic bool) {
+	builder.PrependBoolSlot(3, semantic, false)
+}
+func PartitionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/itr/itrfb/Peek.go

@@ -0,0 +1,79 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Peek struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsPeek(buf []byte, offset flatbuffers.UOffsetT) *Peek {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Peek{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishPeekBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsPeek(buf []byte, offset flatbuffers.UOffsetT) *Peek {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Peek{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedPeekBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Peek) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Peek) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Peek) Start() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Peek) MutateStart(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(4, n)
+}
+
+func (rcv *Peek) Length() uint32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetUint32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Peek) MutateLength(n uint32) bool {
+	return rcv._tab.MutateUint32Slot(6, n)
+}
+
+func PeekStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func PeekAddStart(builder *flatbuffers.Builder, start uint64) {
+	builder.PrependUint64Slot(0, start, 0)
+}
+func PeekAddLength(builder *flatbuffers.Builder, length uint32) {
+	builder.PrependUint32Slot(1, length, 0)
+}
+func PeekEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/itr/itrfb/Recurse.go

@@ -0,0 +1,86 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Recurse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsRecurse(buf []byte, offset flatbuffers.UOffsetT) *Recurse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Recurse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishRecurseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsRecurse(buf []byte, offset flatbuffers.UOffsetT) *Recurse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Recurse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedRecurseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Recurse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Recurse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Recurse) SubQuery() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Recurse) ContextKey() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Recurse) DepthHint() byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetByte(o + rcv._tab.Pos)
+	}
+	return 3
+}
+
+func (rcv *Recurse) MutateDepthHint(n byte) bool {
+	return rcv._tab.MutateByteSlot(8, n)
+}
+
+func RecurseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(3)
+}
+func RecurseAddSubQuery(builder *flatbuffers.Builder, subQuery flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(subQuery), 0)
+}
+func RecurseAddContextKey(builder *flatbuffers.Builder, contextKey flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(contextKey), 0)
+}
+func RecurseAddDepthHint(builder *flatbuffers.Builder, depthHint byte) {
+	builder.PrependByteSlot(2, depthHint, 3)
+}
+func RecurseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/itr/itrfb/ToolExec.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ToolExec struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsToolExec(buf []byte, offset flatbuffers.UOffsetT) *ToolExec {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ToolExec{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishToolExecBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsToolExec(buf []byte, offset flatbuffers.UOffsetT) *ToolExec {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ToolExec{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedToolExecBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ToolExec) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ToolExec) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ToolExec) ToolName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ToolExec) ArgsJson() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func ToolExecStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func ToolExecAddToolName(builder *flatbuffers.Builder, toolName flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(toolName), 0)
+}
+func ToolExecAddArgsJson(builder *flatbuffers.Builder, argsJson flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(argsJson), 0)
+}
+func ToolExecEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/itr/itrfb/ToolRequest.go

@@ -0,0 +1,170 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ToolRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsToolRequest(buf []byte, offset flatbuffers.UOffsetT) *ToolRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ToolRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishToolRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsToolRequest(buf []byte, offset flatbuffers.UOffsetT) *ToolRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ToolRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedToolRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ToolRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ToolRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ToolRequest) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ToolRequest) CmdType() CmdType {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return CmdType(rcv._tab.GetInt8(o + rcv._tab.Pos))
+	}
+	return 0
+}
+
+func (rcv *ToolRequest) MutateCmdType(n CmdType) bool {
+	return rcv._tab.MutateInt8Slot(6, int8(n))
+}
+
+func (rcv *ToolRequest) PayloadType() CommandPayload {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return CommandPayload(rcv._tab.GetByte(o + rcv._tab.Pos))
+	}
+	return 0
+}
+
+func (rcv *ToolRequest) MutatePayloadType(n CommandPayload) bool {
+	return rcv._tab.MutateByteSlot(8, byte(n))
+}
+
+func (rcv *ToolRequest) Payload(obj *flatbuffers.Table) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		rcv._tab.Union(obj, o)
+		return true
+	}
+	return false
+}
+
+func (rcv *ToolRequest) DagPlan(obj *DAGPlan) *DAGPlan {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(DAGPlan)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func (rcv *ToolRequest) Timestamp() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ToolRequest) MutateTimestamp(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(14, n)
+}
+
+func (rcv *ToolRequest) Depth() byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetByte(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ToolRequest) MutateDepth(n byte) bool {
+	return rcv._tab.MutateByteSlot(16, n)
+}
+
+func (rcv *ToolRequest) SessionKey() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ToolRequest) ToolCallId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func ToolRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(9)
+}
+func ToolRequestAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func ToolRequestAddCmdType(builder *flatbuffers.Builder, cmdType CmdType) {
+	builder.PrependInt8Slot(1, int8(cmdType), 0)
+}
+func ToolRequestAddPayloadType(builder *flatbuffers.Builder, payloadType CommandPayload) {
+	builder.PrependByteSlot(2, byte(payloadType), 0)
+}
+func ToolRequestAddPayload(builder *flatbuffers.Builder, payload flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(payload), 0)
+}
+func ToolRequestAddDagPlan(builder *flatbuffers.Builder, dagPlan flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(dagPlan), 0)
+}
+func ToolRequestAddTimestamp(builder *flatbuffers.Builder, timestamp uint64) {
+	builder.PrependUint64Slot(5, timestamp, 0)
+}
+func ToolRequestAddDepth(builder *flatbuffers.Builder, depth byte) {
+	builder.PrependByteSlot(6, depth, 0)
+}
+func ToolRequestAddSessionKey(builder *flatbuffers.Builder, sessionKey flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(sessionKey), 0)
+}
+func ToolRequestAddToolCallId(builder *flatbuffers.Builder, toolCallId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(toolCallId), 0)
+}
+func ToolRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/itr/itrfb/ToolResponse.go

@@ -0,0 +1,139 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ToolResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsToolResponse(buf []byte, offset flatbuffers.UOffsetT) *ToolResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ToolResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishToolResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsToolResponse(buf []byte, offset flatbuffers.UOffsetT) *ToolResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ToolResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedToolResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ToolResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ToolResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ToolResponse) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ToolResponse) Result() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ToolResponse) IsError() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *ToolResponse) MutateIsError(n bool) bool {
+	return rcv._tab.MutateBoolSlot(8, n)
+}
+
+func (rcv *ToolResponse) LeakDetected() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *ToolResponse) MutateLeakDetected(n bool) bool {
+	return rcv._tab.MutateBoolSlot(10, n)
+}
+
+func (rcv *ToolResponse) CostTokens() uint32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetUint32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ToolResponse) MutateCostTokens(n uint32) bool {
+	return rcv._tab.MutateUint32Slot(12, n)
+}
+
+func (rcv *ToolResponse) RedactedKeys(j int) []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		a := rcv._tab.Vector(o)
+		return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
+	}
+	return nil
+}
+
+func (rcv *ToolResponse) RedactedKeysLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func ToolResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(6)
+}
+func ToolResponseAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func ToolResponseAddResult(builder *flatbuffers.Builder, result flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(result), 0)
+}
+func ToolResponseAddIsError(builder *flatbuffers.Builder, isError bool) {
+	builder.PrependBoolSlot(2, isError, false)
+}
+func ToolResponseAddLeakDetected(builder *flatbuffers.Builder, leakDetected bool) {
+	builder.PrependBoolSlot(3, leakDetected, false)
+}
+func ToolResponseAddCostTokens(builder *flatbuffers.Builder, costTokens uint32) {
+	builder.PrependUint32Slot(4, costTokens, 0)
+}
+func ToolResponseAddRedactedKeys(builder *flatbuffers.Builder, redactedKeys flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(redactedKeys), 0)
+}
+func ToolResponseStartRedactedKeysVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ToolResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/itr/itrfb/ToolSearch.go

@@ -0,0 +1,75 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package itrfb
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ToolSearch struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsToolSearch(buf []byte, offset flatbuffers.UOffsetT) *ToolSearch {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ToolSearch{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishToolSearchBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsToolSearch(buf []byte, offset flatbuffers.UOffsetT) *ToolSearch {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ToolSearch{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedToolSearchBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ToolSearch) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ToolSearch) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ToolSearch) Query() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ToolSearch) MaxResults() byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetByte(o + rcv._tab.Pos)
+	}
+	return 10
+}
+
+func (rcv *ToolSearch) MutateMaxResults(n byte) bool {
+	return rcv._tab.MutateByteSlot(6, n)
+}
+
+func ToolSearchStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func ToolSearchAddQuery(builder *flatbuffers.Builder, query flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(query), 0)
+}
+func ToolSearchAddMaxResults(builder *flatbuffers.Builder, maxResults byte) {
+	builder.PrependByteSlot(1, maxResults, 10)
+}
+func ToolSearchEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}