# Cluster 3 — Intent-Mapping (Jofito and Related)

**Sub-report for Section 2 of the Intent-Based Scripting Languages survey**
**Track:** `intent_dsl_survey_20260612`
**Written by:** Tier 2 sub-agent (cluster 3 research)
**Sources:** Jofito video transcript + README, jq Wikipedia + official site, nagent tag protocol docs, WebAssembly Wikipedia

---

## Entry: Jofito (Jody Bruchon, 2023–2026)

**What it is.** Jofito is a C-based script engine for building advanced, high-performance file and disk management tools. It frames itself as an "intent mapping engine" — the user writes declarative intent (e.g., "find all pictures, filter out JPEGs, print the list"), and Jofito decomposes that intent into platform-optimal operations, automatically parallelizing across cores and optimizing away unnecessary data movement. The core technical innovations are arena allocation (bulk memory management with no per-object overhead), the leader/chaser thread model (pipeline stages chase each other through a shared arena rather than through separate process-bounded buffers), and "pipe coalescing" (find/grep/sort/unique collapse into a single in-memory script).

**What we take from it.** The "intent mapping engine" framing is the philosophical anchor for the DSL's Tier 2 (pipeline) verbs. Where traditional shells require the user to manually sequence `find | grep | sort | uniq` and pay the context-switch tax at each `|` boundary, Jofito's model lets the user say "here is the intent" and the engine handles the decomposition. The DSL's `scan -> filter -> select -> print` pipeline chain is directly inspired by Jofito's `scandir(...) : filter : print` predicate chain. The arena/leader-chaser model is not directly borrowed (the DSL is interpreted in Python, not compiled to optimal C), but the *design contract* — that verbs should be able to run in parallel without intermediate serialization — influences how Tier 2 verbs are specified.

### Detailed Analysis

#### The Old Way: Unix Pipeline Performance Tax

Jofito's video presentation opens with a demolition of the Unix pipeline model. The canonical example:

```sh
find . -type f | grep -e '\.jpg$' | grep -e '\.png$'
```

Jofito's analysis (lines 28–49 of the transcript) is blunt: to a layman, this is "cryptic crap." But the deeper problem is performance. Each `|` boundary in a Unix pipeline incurs:

1. **Context switch** — the producer process is suspended, the consumer process is scheduled (line 97: "throwing away your CPU state and trashing your caches")
2. **Pipe buffer overhead** — data is copied from producer's address space to kernel pipe buffer to consumer's address space (lines 90–94)
3. **Cache destruction** — each separate process has its own working set that blows out the L1 cache of the next (lines 106–119: "you're destroying your cache coherency by duplicating data")

The transcript is vivid on this point:

> "Every single time you do a context switch, you're basically throwing away your CPU state and trashing your caches, which makes everything run slower, because now all this stuff you're doing the work for here is no longer in main memory, or rather in the L1 cache, which is your CPU's execution core's main memory."  
> — `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:106–113`

And on the inefficiency of grep specifically:

> "Grep is general regular expression parser. It's a big fancy state machine that takes a while to spin up and is not all that fast at just simple globbing, which is the term used to refer to finding basically finding substrings in a string except in reverse."  
> — `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:65–69`

#### The Jofito Solution: Predicate Chains with Arena Allocation

Jofito's equivalent to the find/grep pipeline is a single predicate chain expressed as a C-like function call:

```c
list = scandir("/path/here/", {filter !extension=jpg,jpeg}) : print(list)
```

Breaking this down (per the README at `https://codeberg.org/jbruchon/jofito`):

> "if you want to retrieve a list of files like 'find . -type f' but filter out JPEG images, you might write and run this on a Linux x86-64 system:  
> `list = scandir("/path/here/", {filter !extension=jpg,jpeg}) : print(list)`  
> jofito can then take advantage of the low-level system call 'getdents64' to perform faster directory reads, SSE or AVX for finding the file extensions, and use the 'write' system call to output length-specified final strings."

The key structural idea is the curly-brace `{filter ...}` predicate. Unlike Unix pipelines where each stage is a separate process with its own output buffer, Jofito predicates run as threads sharing a single memory arena. The transcript (lines 155–174) explains:

> "Scan directory, however, has this curly brace filter... Filter is a generic predicate that calls a particular kind of filtration on a string or list of strings, and then filters them as you want them... It's much easier to read. We know we're scanning a directory."

#### Arena Allocation and the Leader/Chaser Thread Model

The most technically distinctive part of Jofito is the arena + leader/chaser model (lines 193–269). An arena is a large, pre-allocated memory region into which all intermediate results are written in order. The predicate chain (scan → filter → print) runs as three threads:

1. **Scanner** (leader) reads directory entries and stores them sequentially in the arena.
2. **Filter** (chaser 1) trails behind the scanner, deallocating entries that don't match the predicate as it encounters them.
3. **Printer** (chaser 2) trails behind the filter, outputting matching entries and freeing them as it goes.

The critical insight (lines 224–244):

> "So, we have a situation here where if you have three cores or threads on a machine, the directory scan can be happening... then the filtration of that scan will be happening in another thread or on another core at the same time... scanning, filtering, and printing can all happen on a modern machine with multiple cores simultaneously."

And on cache coherency (lines 270–285):

> "The likelihood of say the scanner here has just loaded bad.text into the list and then the filter here has filtered just qualified abc.jpeg and the print has just printed xyz.png... if you have predicates that are fast enough, they're all kind of working in lockstep, which means that these items are still hot in the level one instruction and data caches as it's iterating through this list."

Terminal objects (entries filtered out) are immediately deallocated from the arena without causing index mismatches for downstream predicates — the arena uses an indirection block scheme so that high-level primitives point to fixed indirection entries while low-level locations can be compacted (lines 335–355). This is the "write the optimization once, reap the benefits everywhere" contract: once Jofito knows how to optimally fuse scan+filter+print for a given filesystem, that optimization applies to every subsequent invocation without the user re-specifying it.

#### Pipe Coalescing: The Killer Feature for DSL Design

The most directly relevant feature for the DSL is "pipe coalescing" (lines 376–410). When the Unix shell sees `find ... | grep ... | sort | uniq`, each utility is a separate process. Jofito's pipe coalescing detects when multiple utilities in a pipeline are all Jofito scripts and collapses them into a single in-memory script:

> "I've come up with some tech called pipe coalescing where find and grep see their part of a pipeline. Find and grep see their the same Jofito executable. And then find is the head, so it's the coordinator. And all the subordinates down the pipeline reach out to the head and say, 'Hey, here's my script, here's my parameters, integrate me into you and I'll just become a hollow pipe that sends the final results down the line. Thus, find and grep and sort and unique and whatever else your big long stupid pipeline might use all get collapsed by Jofito... into one unified Jofito script in memory that then performs all these actions and thus can optimize away um cases where, for example, it would be wasteful to get certain information, um it can optimize away that stuff and do it faster than you would ever be able to do it with a normal pipeline on your own."

This is the direct precedent for the DSL's Tier 2 pipeline verb `pipe` — the idea that a chain of verbs (`scan -> filter -> sort -> dedupe`) can be coalesced into a single pass rather than spawning intermediate processes.

#### The Intent Mapping Engine Manifesto

The 2026 README update (`https://codeberg.org/jbruchon/jofito`) names the design philosophy explicitly:

> "2026 UPDATE NOTE: This tool was originally intended to act like a sort of 'SQL for managing filesystems' but I am generalizing it out to become an 'intent mapping engine' instead. I intend to replace coreutils, findutils, grep, and sed with 'scripted' commands of intent. The general idea is that if you write a program in the jofito language, you can not only run it anywhere that jofito has been ported, but you also get the maximal performance and safety offered by the underlying system and hardware. Essentially, jofito is a 'write the optimization once, reap the benefits everywhere' system that takes what the user wants to accomplish (intent) as input and decomposes it into operations that make the most sense for the current system."

The "intent mapping engine" framing is the fourth anchor claim for section 1 of the main report.

### Code Examples from Source

**Jofito predicate chain (from README):**
```c
list = scandir("/path/here/", {filter !extension=jpg,jpeg}) : print(list)
```

**Equivalent Unix pipeline (from transcript line 34–38):**
```sh
find . -type f | grep -e '\.jpg$' | grep -e '\.png$'
```

**Pipe coalescing concept (from transcript lines 383–402):**
```sh
# Without coalescing: 4 separate processes
find . -type f | grep -e '\.jpg' | sort | uniq
# Jofito coalesces find+grep+sort+unique into one in-memory script
```

### Take (for Section 1 Anchor Claims)

- **Anchor 4 (Intent Mapping Framing):** "Jofito is a 'write the optimization once, reap the benefits everywhere' system that takes what the user wants to accomplish (intent) as input and decomposes it into operations that make the most sense for the current system." (`https://codeberg.org/jbruchon/jofito`, 2026 UPDATE NOTE) — this is the naming citation for the DSL's "intent-based" design philosophy.
- **Tier 2 verb justification:** The `scan -> filter -> select -> print` pipeline chain maps directly to Jofito's `scandir(...) : filter : print` predicate chain (`docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:138–174`).
- **Pipe coalescing → DSL `pipe` verb:** Jofito's pipe coalescing (collapsing find+grep+sort+unique into one in-memory script, `transcript:376–410`) is the design precedent for the DSL's `pipe` verb — the idea that chained verbs can be fused into a single-pass execution plan.
- **Arena/leader-chaser → Tier 2 execution model:** While not implementing the full arena model, the DSL's Tier 2 verbs are specified to be parallelizable and to avoid intermediate serialization, honoring Jofito's cache-coherency contract (`transcript:270–285`).

---

## Entry: jq (Stephen Dolan, 2012–)

**What it is.** jq is a lightweight, flexible command-line JSON processor built in C, described by its creator Stephen Dolan as "like sed for JSON data." It applies the Unix filter-pipeline model to structured JSON data: programs are composed of filters that transform input into output, chained with the `|` operator. Unlike sed (which operates on lines of text), jq operates on JSON values — arrays, objects, scalars — using a purely functional, composable filter language.

**What we take from it.** The DSL takes two things from jq: (1) the `|` pipe idea (replaced with `->` in our DSL to avoid conflict with shell usage), and (2) the filter-as-expression style where every filter is a value that can be composed. jq's insight — that data transformation should be expressed as a composition of small, reusable filter functions rather than as imperative step-by-step instructions — is the same insight behind the DSL's Tier 2 verbs.

### Detailed Analysis

#### The Pipe Operator and Filter Composition

jq's core innovation is applying the Unix pipe model to structured data. From the Wikipedia entry (`https://en.wikipedia.org/wiki/Jq_(programming_language)`):

> "In jq, programs consist of filters that can be composed in pipelines that perform a variety of operations on their inputs."

The jq manual (cited in the Wikipedia article) uses the `|` operator as a pipeline combinator. A jq program like `.parse | .categories | .[] | .["*"]` navigates a nested JSON structure by chaining filters: `.parse` extracts the `parse` key, `.categories` extracts `categories`, `.[]` iterates over array items, and `.["*"]` extracts the `*` key from each.

The jq website (`https://jqlang.org/`) frames it this way:

> "jq is like sed for JSON data — you can use it to slice and filter and map and transform structured data with the same ease that sed, awk, grep and friends let you play with text."

The original description (2013, archived at `https://en.wikipedia.org/wiki/Jq_(programming_language)` citing `http://jqlang.github.io/jq`):

> "like sed for JSON data"

The filter composition model means every jq expression is itself a filter that can be used as a sub-expression in a larger pipeline. There are no statements, only expressions that produce values. This is the "tacit" or "point-free" programming style — functions compose without naming their arguments.

#### jq's Type System and Streaming Parser

jq's type system is minimal and maps directly to JSON: strings, numbers, booleans, null, arrays, objects. Every JSON value is a jq value. The streaming parser (added in jq 1.5) produces a stream of `[path, value]` arrays for all "leaf" paths in a JSON document, enabling memory-efficient processing of JSON inputs too large to fit in memory.

This is relevant to the DSL because the Tier 2 pipeline verbs operate on similar data shapes — the DSL's `select` and `filter` verbs work on record streams (similar to jq's object iteration), and the `gather` verb could theoretically use a streaming approach for large file sets.

#### jq Implementations and Influence

jq has been reimplemented in Go (gojq), Rust (jaq), and even in jq itself (jqjq). The Wikipedia article notes that jaq uses denotational semantics to formalize jq behavior where the original jq documentation is unclear. This is a validation of jq's design: it is important enough to warrant multiple independent reimplementations, each trying to get the semantics right.

The DSL's ambition to be interpretable by multiple agent backends (not just the current Python implementation) has a parallel in jq's multi-implementation ecosystem.

#### Syntax Example from Source

From the Wikipedia jq article's tutorial section:

```jq
# The jq pipeline (abbreviated form):
."parse" | .categories | .[] | .["*"]

# Equivalent named filter example from the Wikipedia article (def tobase):
def tobase($b):
    def digit: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[.:.+1];
    def mod: . % $b;
    def div: ((. - mod) / $b);
    def digits: recurse( select(. >= $b) | div) | mod ;
    select(2 <= $b and $b <= 36)
    | [digits | digit] | reverse | add;
```

This shows jq's functional composition style: `select(...) | [digits | digit] | reverse | add` chains filters without naming intermediate values.

### Take

- **DSL `->` pipe operator:** jq's `|` pipe is the conceptual precedent for the DSL's `->` pipeline operator. The DSL replaces `|` with `->` to avoid conflict with shell usage and to make the DSL parseable without shell-aware lexing.
- **Filter-as-expression style:** jq's model where every filter is a composable expression that produces a value directly maps to the DSL's Tier 2 verbs — `scan`, `select`, `filter`, `map`, `fold` — which are expressions that produce streams, not imperative statements.
- **Tier 2 verb semantics:** The `select` verb in particular mirrors jq's `select(condition)` filter, which passes only values matching a condition. The `dedupe` verb mirrors jq's `unique` filter.

---

## Entry: nagent's Tag Protocol (Mike Acton, 2024\u20132025)

**What it is.** nagent is Mike Acton's autonomous coding agent framework (`github.com/macton/nagent`). Its §4 "visible output protocol" uses a self-closing XML-ish tag format (e.g., `<nagent-read path="src/foo.py"/>`) that the agent emits as text. A parser (`nagent_tags.py`) matches tags to handler functions (`execute_read`, etc.). The protocol is explicitly not XML — first matching close-tag wins, there is no entity escaping, and the tag format is designed for human readability and LLM emit-ability rather than for machine interchange fidelity.

**What we explicitly reject (and what we take):** We **take** the idea of a compact, human-readable structured protocol for tool invocation — the `<name attr="value"/>` surface syntax that external agents can emit without knowing the underlying function-call JSON schema. We **reject** the XML angle-bracket notation per the user's explicit instruction: "ignore its record formats as they problably will be less xml/json based as I don't like them." (`conductor/tracks/nagent_review_20260608/decisions.md:50` citing user signal).

### Detailed Analysis

#### The Tag Protocol Design

The nagent tag protocol was documented in `nagent_takeaways_20260608.md` (lines 210–230). The core design:

> "`<nagent-read path="..."/>` is a self-closing tag. The model emits it; the parser matches; `execute_read` runs. The model doesn't need to know the function-call schema for the LLM SDK — it just needs to emit text containing a tag." (`conductor/tracks/nagent_review_20260608/nagent_takeaways_20260608.md:212`)

The contrast with standard function calling is explicit:

> "The training data for 'emit a `<nagent-read>` tag' is zero; the training data for 'emit a `read_file` tool call' is high. *Function calling wins on capability and on training; tag protocols win on debuggability.*" (`nagent_takeaways_20260608.md:214`)

The protocol was later refined in nagent v2 with an explicit parser (`nagent_tags.py`) replacing regex-based parsing. The `agent_review_v2_1_20260612.md` documents it (line 50):

> "`nagent_tags.py`: ~160 (6KB). The new explicit tag parser. Replaces regex parsing. `TagNode` dataclass with `name, attrs, content, self_closing, start, end`. `parse_tag_document` walks whitespace + elements. `find_block_span`, `extract_block`, `replace_first_block`, `remove_first_block` are the public helpers. **The protocol is XML-ish, not XML** — first matching close tag wins; no entity escaping."

#### The Explicit "We Reject This" Note

The user signal in `decisions.md` is unambiguous (line 50, spec.md line 50):

> "**Not** adopting XML/JSON record formats. Per the user: 'ignore its record formats as they problably will be less xml/json based as I don't like them.'"

And in `decisions.md` line 119 (Candidate 4 framing):

> "The existing JSON function-calling format forces the user to read verbose `{"name": "...", "args": {...}}` blobs."

The intent-based DSL examples listed in `decisions.md:124–128` use angle brackets, but the user explicitly rejected that notation. The DSL's notation must find a different surface syntax that preserves the structured-protocol properties (compact, human-readable, LLM-emit-able) without using `<>` or `{}` as structural delimiters.

#### Why We Reject the XML Angle-Bracket Approach

The specific reasons for rejecting XML angle-bracket notation:

1. **User preference:** The user explicitly said "I don't like them" (`decisions.md:50`)
2. **LLM training data mismatch:** `<nagent-read>` has zero training data in existing models; angle-bracket notation would require fine-tuning or prompt engineering that a more conventional syntax would not (`nagent_takeaways_20260608.md:214`)
3. **Ambiguity with HTML/Markdown:** Angle-bracket notation conflicts with common markup patterns in the contexts where the DSL will be used (agent prompts, tool outputs)
4. **The protocol properties we DO want:** compact (not JSON-verbose), human-readable, structured (name + attributes), LLM-emit-able

The structured-protocol *idea* (a named operation with typed attributes, not a JSON blob) is the right direction. The notation just needs to be different.

#### The Bridge DSL Concept

The `nagent_takeaways_20260608.md` proposes a bridge DSL (lines 216–222) as the right model:

```
<ms-tool name="read_file" path="src/foo.py" />
<ms-tool name="py_get_skeleton" path="src/foo.py" symbol="MyClass" />
```

The document notes this is Decision candidate #4 reframed as a *bridge* DSL rather than a Meta-Tooling-side DSL. The Application's function-calling stays the same. The bridge DSL is what external agents emit.

The DSL's notation must serve the same purpose — compact, structured tool invocation by LLMs — without using angle brackets. Possible alternatives (not mandated here, just noted for the Tier 1's synthesis):
- `read_file src/foo.py` (verb-first, space-delimited)
- `read_file(src/foo.py)` (function-call-like but simpler than JSON)
- `read_file "src/foo.py"` (quoted-argument form)

### Take

- **Structured protocol idea (TAKEN):** The idea of a compact, named-operation-with-attributes format for tool invocation is right. External agents can emit this format without knowing the function-call JSON schema.
- **XML angle brackets (REJECTED):** Per the user ("I don't like them"), the DSL must use a different notation. The specific reasons: user preference, LLM training data mismatch, HTML/Markdown ambiguity.
- **nagent's `name="..."` attribute syntax:** The idea of named attributes (as opposed to positional arguments) is retained — `scan dir=".", filter_extension="jpg"` reads more naturally than `scan ".", "jpg"` for complex tool calls.
- **Self-closing tag for no-content operations:** The concept of a self-closing tag (no content body needed) maps to the DSL's distinction between verbs that produce output and verbs that are used for their side effect.

---

## Entry: WebAssembly (W3C, 2017–)

**What it is.** WebAssembly (Wasm) is a binary instruction format and text format for a portable, streaming-compiled virtual stack machine. It defines a compact, sectioned binary format with linear memory (a single growable byte array separate from the call stack) and structured control flow (no `goto`; all branches are scoped via `block`/`loop`/`if`/`end`).

**What we take from it.** One paragraph only: Wasm's linear memory model is the modern reference for the "tape drive" argument-passing analogy that grounds the DSL's data-passing semantics. A program that processes a stream of records operates on a single linear memory region; records are not objects with individual heap allocations but entries in a contiguous buffer. This is the execution model Jofito implements in C and the model the DSL's Tier 2 verbs are specified against.

### Detailed Analysis

#### Linear Memory

From the Wikipedia article on WebAssembly (`https://en.wikipedia.org/wiki/WebAssembly`):

> "Data in memory is stored in a large, growable array of bytes termed a linear memory. Linear memory is separate from the wasm module's call stack and code and the engine's memory. This allows running wasm code in the same process as the JavaScript virtual machine it's embedded in without violating memory safety."

The linear memory model means Wasm has no heap fragmentation, no garbage collection overhead for short-lived objects, and no per-allocation metadata. All data lives in one region; the engine can prefetch and cache it efficiently. This is the same contract Jofito's arena provides: entries are stored contiguously and compacted as they become dead.

#### Sectioned Binary Format and Streaming

> "The binary format is straightforward and designed to allow streaming compiling, so compiling can begin before the module is finished downloading, and to allow functions to be compiled in parallel." (`https://en.wikipedia.org/wiki/WebAssembly`)

The sectioned binary format means the Wasm loader can start executing as soon as the header and function signatures are loaded, without waiting for the full module. For the DSL, this suggests a parsing strategy where verb names and signatures are parsed first (cheap, early validation) and arguments are parsed on demand.

#### Structured Control Flow

> "Unlike typical assembly languages, wasm only uses structured control flow similar to high-level programming languages. The intentional lack of support for jump instructions makes it simple to validate and compile wasm code in a single pass, and makes it easier to read code disassembled into the text format." (`https://en.wikipedia.org/wiki/WebAssembly`)

This is relevant to the DSL's error recovery model: structured recovery (try/recover blocks with explicit nesting) is easier to validate and recover from than unstructured jumps. The DSL's `try { ... } recover { ... }` envelope mirrors Wasm's structured control flow.

### Take

- **Linear memory → DSL Tier 2 execution model:** Wasm's linear memory (single contiguous buffer, no per-record heap allocation) is the implementation reference for the execution model Tier 2 verbs are specified against. Jofito's arena is the C-level precedent.
- **Streaming parse → DSL parsing strategy:** Wasm's ability to start compiling before the full module is loaded suggests the DSL parser can validate verb names and signatures early (cheap) and defer argument parsing (potentially expensive for large file lists) to execution time.
- **Structured control flow → DSL error recovery:** Wasm's block/loop/if/end structured control flow is the model for the DSL's `try/recover` envelope. Both enforce nesting correctness at parse time.

---

## Synthesis for the DSL

This section maps each Tier 3 (shell) and Tier 2 (pipeline) verb in the DSL to the specific Jofito/jq entry that grounds it. The Tier 1 will use this to write section 1's anchor claim 4 (Jofito → intent-mapping framing) and section 4's Tier 2/3 verb justifications.

### Tier 2 — Data-Oriented Pipeline Verbs

These verbs implement the Jofito "predicate chain" model. They operate on record streams (not individual files or values) and are designed to be parallelizable without intermediate serialization.

| DSL Verb | Grounding Entry | Key Citation |
|---|---|---|
| `scan` | Jofito `scandir()` | Jofito's `scandir("/path/here/", {filter ...})` predicate — the leader of the leader/chaser chain. The DSL's `scan` is the first verb in every pipeline, the entry point for data. | `transcript:138–174`, `README:scandir example` |
| `filter` | Jofito `{filter ...}` predicate | Jofito's filter predicate chases the scanner through the arena, deallocating non-matching entries. The DSL's `filter` similarly screens records based on a condition. | `transcript:155–174`, `transcript:209–244` |
| `select` | jq `select(condition)` filter | jq's `select(.field == "value")` passes only matching values. The DSL's `select` is the same concept — a filter that tests a condition and passes records that satisfy it. | `https://en.wikipedia.org/wiki/Jq_(programming_language):Syntax_and_semantics/Filters` |
| `map` | jq map/transform filters | jq's ability to transform every element in a stream (`.[] | .field`) maps to the DSL's `map` — applying a transformation to each record in the stream. | `https://jqlang.org/` ("slice and filter and map and transform") |
| `fold` | jq reduction (`reduce`) | jq's `reduce` operator accumulates a stream into a single value. The DSL's `fold` similarly reduces a record stream to an aggregate result. | `https://en.wikipedia.org/wiki/Jq_(programming_language):Syntax_and_semantics/Forms` |
| `sort` | Jofito implicit in predicate chain | Jofito's pipe coalescing handles sort+unique in the same pass. The DSL's `sort` verb is a pipeline stage for ordering records. | `transcript:397–402` |
| `dedupe` | jq `unique` filter | jq's `unique` filter removes duplicate values from a stream. The DSL's `dedupe` serves the same purpose. | `https://en.wikipedia.org/wiki/Jq_(programming_language):Filters` |
| `group` | jq `group_by` | jq has `group_by(.field)` functionality. The DSL's `group` verb collects records sharing a key into sub-streams. | `https://jqlang.org/manual/` (jq manual) |
| `arena { }` | Jofito arena allocation | Jofito's arena is a bulk-allocated memory region where all intermediate results are stored contiguously. The DSL's `arena { }` block scopes a pipeline's working memory — it is a performance hint that the enclosed pipeline should use a contiguous buffer rather than per-record allocations. | `transcript:193–209`, `README:arena description` |
| `scatter` | Jofito leader/chaser model | Jofito's filter predicate can run in parallel with the scanner, "scattering" work across cores. The DSL's `scatter` verb explicitly forks a pipeline across multiple workers. | `transcript:250–269` |
| `gather` | Jofito leader/chaser model | The print predicate "gathers" the filtered stream from the arena. The DSL's `gather` collects scattered sub-streams back into a single stream. | `transcript:244–269` |
| `pipe` | Jofito pipe coalescing | Jofito's pipe coalescing collapses `find | grep | sort | uniq` into one in-memory script. The DSL's `pipe` verb explicitly fuses a sub-pipeline into a single-pass execution plan. This is the most directly borrowed concept — the idea that a pipeline chain can be optimized as a unit rather than executed stage by stage. | `transcript:376–410` |

### Tier 3 — Shell Verbs

These verbs wrap existing MCP tools and provide the shell-scripting surface. They are the "imperative veneer" over the declarative Tier 2 pipeline. Each is grounded in either Jofito (for file operations) or jq (for data transformation), or serves as an escape hatch to existing Unix tooling.

| DSL Verb | Grounding Entry | Key Citation |
|---|---|---|
| `read` | nagent tag protocol (`<nagent-read path="..."/>`) | The idea of a compact, named-operation format for file reading. NOT the angle-bracket notation — the concept of a structured protocol that an LLM can emit without knowing the underlying function-call schema. The DSL's `read` is the Tier 3 surface for `mcp_client.py`'s `read_file` tool. | `nagent_takeaways_20260608.md:212`, `decisions.md:124` |
| `edit` | nagent tag protocol (structured edit tag) | Same structured-protocol idea as `read`. The DSL's `edit` verb maps to the proposed DSL notation for surgical edits (e.g., `edit src/foo.py:42-50:new_code`). | `decisions.md:126` |
| `glob` | Jofito `scandir` with extension filter | Jofito's `scandir` with a `{filter extension=...}` predicate is a more ergonomic glob. The DSL's `glob` wraps the existing MCP `Path` globbing tools but is also the entry point that feeds `scan`. | `README:scandir example` |
| `search` | jq filter composition | jq's filter composition (`.foo | .bar | .baz`) as a model for composing search predicates. The DSL's `search` verb applies a predicate to find records matching criteria. | `https://jqlang.org/` |
| `exec` | Jofito pipe coalescing | The escape hatch: when the DSL's pipeline verbs aren't sufficient, `exec` runs an arbitrary shell command. This is the "fall back to Unix" safety valve, analogous to Jofito falling back to individual system calls when the arena model doesn't apply. | `transcript:376–410` |
| `run` | Jofito script execution | Jofito scripts are compiled and run as units. The DSL's `run` verb executes a named script or pipeline, analogous to running a Jofito program. | `README:general idea` |
| `test` | nagent tag protocol (structured test tag) | Same structured-protocol idea as `read`/`edit`. The DSL's `test` verb maps to the proposed DSL notation for running specific tests. | `decisions.md:127` |
| `discover` | jq filter composition + Jofito intent | The "discovery" intent from `decisions.md:128` (`<discover what calls X>`) combines jq-style navigation with Jofito's intent-mapping philosophy: the user says what they want to find, the system figures out how. | `decisions.md:128`, `README:intent mapping` |
| `mcp` | nagent self-describing tools | nagent's `--description` exit pattern (`nagent_takeaways_20260608.md:236–244`) lets each tool describe itself. The DSL's `mcp` verb is the escape hatch to raw MCP tool dispatch, with self-description metadata available. | `nagent_takeaways_20260608.md:236–244` |

### Mapping Summary for Tier 1

**Section 1, Anchor Claim 4 (Intent Mapping Framing):** Cite Jofito README 2026 UPDATE NOTE: "jofito is a 'write the optimization once, reap the benefits everywhere' system that takes what the user wants to accomplish (intent) as input and decomposes it into operations that make the most sense for the current system." (`https://codeberg.org/jbruchon/jofito`)

**Section 4, Tier 2 Verb Justifications:** Each Tier 2 verb cites Jofito predicate chain (for `scan`, `filter`, `arena`, `scatter`, `gather`, `pipe`) or jq filter composition (for `select`, `map`, `fold`, `sort`, `dedupe`, `group`).

**Section 4, Tier 3 Verb Justifications:** Each Tier 3 verb cites either nagent's structured protocol idea (for `read`, `edit`, `test`, `discover`) or Jofito's tool-replacement model (for `glob`, `exec`, `run`, `mcp`).

**Key design constraint from nagent rejection:** The DSL must NOT use XML angle-bracket notation. The structured-protocol properties (compact, human-readable, LLM-emit-able, name+attributes) must be preserved with a different notation. Possible candidates: verb-first space-delimited (`read_file src/foo.py`), function-call-like parentheses (`read_file("src/foo.py")`), or quoted-argument form. The choice is left to the Tier 1's synthesis.

---

## Citations Index

| Citation | Source | Type |
|---|---|---|
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:28–49` | Jofito video: old pipeline model | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:65–69` | Jofito video: grep inefficiency | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:90–133` | Jofito video: context switch cost | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:106–113` | Jofito video: cache destruction quote | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:138–174` | Jofito video: scandir + filter predicate | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:155–174` | Jofito video: filter predicate explanation | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:193–209` | Jofito video: arena allocation | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:209–269` | Jofito video: leader/chaser model | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:224–244` | Jofito video: thread coordination | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:244–269` | Jofito video: print chasing filter | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:270–285` | Jofito video: cache coherency win | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:297–335` | Jofito video: terminal object destruction | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:335–355` | Jofito video: arena indirection block | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:356–373` | Jofito video: real-world find/grep replacement | File:line |
| `docs/transcripts/Ddme7DwMQBI_jofito_jody_bruchon.txt:376–410` | Jofito video: pipe coalescing | File:line |
| `https://codeberg.org/jbruchon/jofito` | Jofito README (2026 UPDATE NOTE) | URL |
| `conductor/tracks/nagent_review_20260608/nagent_takeaways_20260608.md:212` | nagent tag protocol description | File:line |
| `conductor/tracks/nagent_review_20260608/nagent_takeaways_20260608.md:214` | nagent: function calling vs tag protocol | File:line |
| `conductor/tracks/nagent_review_20260608/nagent_takeaways_20260608.md:216–230` | nagent Bridge DSL proposal | File:line |
| `conductor/tracks/nagent_review_20260608/decisions.md:50` | User: reject XML/JSON record formats | File:line |
| `conductor/tracks/nagent_review_20260608/decisions.md:119` | User signal: explicit want for intent DSL | File:line |
| `conductor/tracks/nagent_review_20260608/decisions.md:124–128` | Intent DSL examples with angle brackets | File:line |
| `conductor/tracks/nagent_review_20260608/agent_review_v2_1_20260612.md:50` | nagent_tags.py explicit parser description | File:line |
| `conductor/tracks/nagent_review_20260608/nagent_takeaways_20260608.md:236–244` | nagent --description self-describing tools | File:line |
| `https://en.wikipedia.org/wiki/Jq_(programming_language)` | jq Wikipedia article | URL |
| `https://jqlang.org/` | jq official site | URL |
| `https://en.wikipedia.org/wiki/WebAssembly` | WebAssembly Wikipedia (linear memory + binary format) | URL |