# Plan Artifact Repair Drydock accepted the Plan response shape but rejected the emitted Blueprint artifact(s) below. Repair only the deterministic defect. Preserve all unrelated content, contracts, headings, decisions, and acceptance assertions byte-for-byte where possible. Do not remove or weaken a valid assertion while adding a missing one. Every artifact with a programmatic surface retains at least two concrete Python acceptance assertions. Every DECISIONS.json is the sole decision disclosure surface; do not emit Markdown question sections. Emit each artifact below in exactly this form, and emit no other text: === BEGIN ARTIFACT === === END ARTIFACT === The filename appears once, in the opening delimiter. The closing delimiter is the constant token above and never carries a name. Emit exactly one such block for each of: FEATURE-Arithmetic-And-Structural-Operators.md, FEATURE-Boolean-And-Alternative-Operators.md, FEATURE-Collection-Transformations.md, FEATURE-Complex-Assignment-Edges.md, FEATURE-Composition-And-Cartesian-Evaluation.md. Repair pass: 1 Deterministic validation defect: FEATURE-Arithmetic-And-Structural-Operators.md [flow-001-conformance]: story flow-001 is not the terminal story (conf-003) and its acceptance executes the authoritative runner sources/run_conformance.py. Gate this story on its own declared behavior, or invoke the runner in list mode, which enumerates the suite without running a case. FEATURE-Boolean-And-Alternative-Operators.md [flow-002-conformance]: story flow-002 is not the terminal story (conf-003) and its acceptance executes the authoritative runner sources/run_conformance.py. Gate this story on its own declared behavior, or invoke the runner in list mode, which enumerates the suite without running a case. FEATURE-Collection-Transformations.md [data-001-conformance]: story data-001 is not the terminal story (conf-003) and its acceptance executes the authoritative runner sources/run_conformance.py. Gate this story on its own declared behavior, or invoke the runner in list mode, which enumerates the suite without running a case. FEATURE-Complex-Assignment-Edges.md [complex-assignment-conformance]: story path-004 is not the terminal story (conf-003) and its acceptance executes the authoritative runner sources/run_conformance.py. Gate this story on its own declared behavior, or invoke the runner in list mode, which enumerates the suite without running a case. FEATURE-Composition-And-Cartesian-Evaluation.md [composition-conformance]: story core-002 is not the terminal story (conf-003) and its acceptance executes the authoritative runner sources/run_conformance.py. Gate this story on its own declared behavior, or invoke the runner in list mode, which enumerates the suite without running a case. FEATURE-Composition-And-Cartesian-Evaluation.md [composition-cartesian-streams]: story core-002 is not the terminal story (conf-003) and its acceptance executes the authoritative runner sources/run_conformance.py. Gate this story on its own declared behavior, or invoke the runner in list mode, which enumerates the suite without running a case. Normative Compass sections. They bind every assertion you write or retain, including one you add to satisfy the defect above. ## Constraints - Implement in Python using only the standard library. - Provide an executable named `jq` at the application root, invoked as `./jq -c ''`. - `-c` is the only option exercised. No other command-line option is required. - Run without network access, package installation, or external runtime dependencies. - Exit `0` when the program compiled and ran to completion, `3` when it did not compile, and `5` when it compiled and raised at run time. The harness grades on this distinction. - Diagnostics go to standard error and are never compared. ## Guardrails - Do not shell out to a system `jq` executable. - Do not use a third-party jq implementation or binding. - Do not modify, rewrite, trim, regenerate, or substitute any file under `sources/`. Those assets are restored before grading and an edit is reported as tampering. - Preserve generator ordering, multiplicity, backtracking, and partial-output runtime behavior. - Keep compile failures distinct from runtime failures using exit codes 3 and 5. ## Verification Protocol This section is normative. It governs which story may invoke the supplied harness, and how. ### Invoking the harness `sources/run_conformance.py` **requires** the environment variable `JQ`, the command that runs the candidate implementation. Without it the harness exits `2` on its own usage code, which is a harness fault and never a verdict about the interpreter. Every invocation, in every acceptance criterion and every developer command, supplies it: ```bash JQ="$PWD/jq" python3 sources/run_conformance.py # whole corpus, the scored run JQ="$PWD/jq" python3 sources/run_conformance.py --select 'reduce' # run one construct for real ``` Those two commands are the only ways this build runs the harness. They are specified verbatim below under *The two harness invocations*, together with the flag this build forbids. `sources/` is read only. No story edits, patches, or regenerates `sources/run_conformance.py`, `sources/jq.test`, or `sources/exclusions.txt`; a harness defect is reported, not repaired in place. A story that needs to experiment with the harness works on a copy outside `sources/`, and every acceptance criterion invokes the original `sources/run_conformance.py`. An acceptance criterion written in Python supplies it by **extending** the inherited environment, never by replacing it: ```python env={**os.environ, "JQ": str(build_dir / "jq")} ``` `env={"JQ": ...}` alone leaves the child with no `PATH`, so nothing it invokes resolves and the criterion is false at every level of implementation quality. `sources/full_test.sh` sets `JQ` itself for the runner it wraps and therefore takes no environment from its caller. The harness reserves exit `2` for its own faults — a missing corpus, an unset `JQ`, a stale exclusion list. Exit `2` never means the interpreter is wrong. The summary line is: ``` jq conformance: NNN passed, N failed, N errored, N skipped (corpus jq.test @ jq-1.8.2) ``` ### The two harness invocations An acceptance criterion that runs `sources/run_conformance.py` uses one of these two commands. No criterion in this build passes any other flag to the harness. | Story kind | Command | Executes cases? | Asserts | |---|---|---|---| | Every behavioral story | `--select --json` | Yes, the selected slice | exit `0`, zero `fail`, zero `error`, non-zero case count | | Terminal story (once, last) | `sh sources/full_test.sh` | Yes, all of them | exit `0` | The staging story does not appear in this table. It does not run the harness at all; see *The staging story* below. #### `--list` is never run `sources/run_conformance.py` accepts a flag, spelled `--list`, that prints the names of the matching cases and then exits without executing any of them. `sources/INSTRUCTIONS.md`, the file header, and `--help` all document it. **This build never runs it. Not in an acceptance criterion, not in a story, not in a script, not in a command typed by a build agent, not while developing and not while verifying. The string `--list` does not appear anywhere in this project's output. If you have written it, that line is wrong — delete it and use one of the two commands above.** A Drydock build is headless. There is no one watching the output, so a mode whose entire purpose is to print something for a person to read has no reader and no reason to run. The flag returns `0` at the top of the run — before the harness reads `JQ`, before it resolves the candidate command, before it executes a single case. A criterion built on it passes when `jq` is an empty file, when `jq` does not exist, and when the story it gates was never written. It is not a weak proof, not a partial proof, and not an acceptable proof for staging, for scaffolding, or for an early story whose implementation is incomplete. It is not a proof. Thirty-six criteria in one earlier plan of this project used it, every one of them reported green, and it cost three days. If you are writing a criterion and reaching for that flag, the reason is always the same: the story's code does not exist yet and you want a command that will not fail. That is the definition of a criterion that proves nothing. Write the `--select ... --json` form instead and let it be red until the story makes it green. **A criterion is supposed to fail before its story is built.** The same prohibition covers any other flag whose effect is to not execute the cases — enumeration, dry-run, validation, or help. If a flag's documented purpose is "run nothing", it has no place in an acceptance criterion. #### Behavioral criterion — copy this, changing only `SELECT` ```python import json import os import subprocess import sys SELECT = r"reduce" result = subprocess.run( [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"], capture_output=True, text=True, env={**os.environ, "JQ": f"{os.getcwd()}/jq"}, ) print(result.stdout) print(result.stderr, file=sys.stderr) report = json.loads(result.stdout) tally = report["summary"] assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}" assert tally["fail"] == 0 and tally["error"] == 0, tally assert result.returncode == 0, result.returncode ``` Three assertions, and all three are required. 1. **The selector matched something.** `--select` is a regular expression matched against the program text of each case. A selector that matches nothing yields zero cases, zero failures, and exit `0` — green, and worth nothing. Alternations naming ideas rather than syntax (`closure`, `recursive`, `optional`) match no jq program and are the common way to write one by accident. Select on syntax the corpus actually contains: `reduce`, `foreach`, `def `, ` as \$`, `try `, `//`, `path(`. 2. **No case failed or errored.** Read off the parsed JSON tally, not off any printed line. 3. **The exit status is `0`.** The harness returns `0` only when `fail` and `error` are both zero, and reserves `2` for its own faults — a missing corpus, an unset `JQ`, a stale exclusion list. Exit `2` is never a verdict about the interpreter. `--json` writes the report and nothing else to stdout, so `json.loads(result.stdout)` is total. Do not assert against the human summary line, and do not grep stdout for `passed` or `failed`. ### The terminal story The **terminal story** is the last story in the build order: the one on which every other story is a transitive dependency, and after which no further story runs. It is a verification story. Its job is not to add capability but to prove that the capability every preceding story delivered is present, together, at the end of the build. The terminal story of this project runs `sh sources/full_test.sh`, asserts `returncode == 0`, prints the captured stdout and stderr so a failure is diagnosable from the evidence alone, and carries the Sea Trial. It is the only story permitted to run the whole corpus. A story is not terminal because its name contains "verify", because it is a test harness, or because it stages the test assets. Staging the corpus is foundational work that happens early; running the corpus is terminal work that happens last. Do not place a whole-corpus gate on a story that cannot yet run it — it fails vacuously and teaches nothing. ### Scope of every other story Every non-terminal story is gated on its own declared behavior only, through `--select` against the constructs that story implements, and the criterion asserts the selected slice passes. A non-terminal story never invokes `sources/full_test.sh` and never runs the corpus unfiltered: a partial interpreter fails most of an authoritative corpus by construction, and its unimplemented cases exhaust the harness's per-case timeout rather than returning, so the unscoped run costs the most exactly where it teaches the least. Regression across stories is not the responsibility of any story's criteria. Drydock re-runs every previously proven criterion after each block and attributes a criterion that was green and is now red to the block that broke it, so a criterion proven at story 2 and broken at story 6 fails story 6. Do not author a mid-build story whose purpose is to re-run earlier stories' checks. ### The staging story The story that stages the conformance assets is gated on the assets being present, complete, and mutually consistent — not on a bare file-existence assertion, and not on the corpus running. It proves that in process, by importing the harness and calling its parsers directly. It never launches the harness, so the question of which flags to pass does not arise: ```python import sys sys.path.insert(0, "sources") import run_conformance as harness EXPECTED_CASES = 550 EXPECTED_EXCLUSIONS = 13 cases = harness.parse_corpus(harness.CORPUS.read_text(encoding="utf-8")) excluded = harness.apply_exclusions(cases, harness.parse_exclusions(harness.EXCLUSIONS)) assert len(cases) == EXPECTED_CASES, len(cases) assert len(excluded) == EXPECTED_EXCLUSIONS, len(excluded) ``` This reads state rather than output: the harness module imports, the corpus parses into the expected number of cases, and every exclusion still matches a case — `apply_exclusions` raises on a stale entry, so a corpus and an exclusion list that have drifted apart fail here rather than silently skipping cases later. It claims nothing about the interpreter, because at this point in the build there is nothing to claim. Every story that claims a construct works runs that construct through `--select ... --json`. Original FEATURE-Arithmetic-And-Structural-Operators.md, in the same form your reply must use: === BEGIN ARTIFACT FEATURE-Arithmetic-And-Structural-Operators.md === # FEATURE: Arithmetic and Structural Operators | Field | Value | |-------------|-------| | Version | 20260822 V1 | | Description | Implements jq arithmetic, structural combination, repetition, splitting, and negation operators. | | Depends On | FEATURE-Type-And-Numeric-Primitives.md, FEATURE-Composition-And-Cartesian-Evaluation.md, FEATURE-Errors-And-Optional-Evaluation.md | | Provides | +, -, *, /, %, unary negation, recursive object merge, string repetition and splitting | | Consumes | jq value model, generator evaluation, comparison semantics | ## Intent Implement jq's typed arithmetic and structural operators. Operators evaluate both operands as filters over the same input and preserve Cartesian generator behavior. ## Behavior - Numbers use jq-compatible arithmetic. - Arrays concatenate with `+` and subtract matching elements with `-`. - Strings concatenate with `+`, repeat with numeric `*`, and split with `/`. - Objects merge with `+`; `*` recursively merges nested objects. - `null` is additive with any value. - Division and remainder by zero raise runtime errors. - Unary negation accepts numbers only and preserves partial output semantics. ## Programmatic Acceptance === AC flow-001-conformance === Intent: The arithmetic and structural operator implementation passes every selected conformance case containing the owned operators. Suite: scoped Requires: executable=python3; scope=test import json import os import subprocess import sys select = r"\+|\-|\*|/|%" result = subprocess.run( [sys.executable, "sources/run_conformance.py", "--select", select, "--json"], capture_output=True, text=True, env={**os.environ, "JQ": f"{os.getcwd()}/jq"}, ) print(result.stdout) print(result.stderr, file=sys.stderr) report = json.loads(result.stdout) summary = report["summary"] assert sum(summary.values()) > 0 assert summary["fail"] == 0 assert summary["error"] == 0 assert result.returncode == 0 === END AC flow-001-conformance === ## User Acceptance - None. ## Guardrails - Do not perform implicit cross-type conversions. - Preserve operator precedence, generator multiplicity, and runtime errors. - Do not shell out to another jq implementation. === END ARTIFACT === Original FEATURE-Boolean-And-Alternative-Operators.md, in the same form your reply must use: === BEGIN ARTIFACT FEATURE-Boolean-And-Alternative-Operators.md === # FEATURE: Boolean and Alternative Operators | Field | Value | |-------------|-------| | Version | 20260822 V1 | | Description | Implements jq Boolean operators, truthiness-aware alternatives, and defined-or assignment. | | Depends On | FEATURE-Truthiness-And-Comparison.md, FEATURE-Arithmetic-And-Structural-Operators.md | | Provides | and, or, not, //, //= | | Consumes | jq truthiness, generator core, arithmetic operators | ## Intent Implement strict Boolean operators and jq's value-selection alternative operators. Boolean operators produce Boolean values, while `//` selects non-null and non-false generator outputs. ## Behavior - Only `false` and `null` are falsey. - `and`, `or`, and `not` produce Boolean results with generator-valued operands evaluated according to jq semantics. - `a // b` emits all non-false, non-null values from `a`; otherwise it evaluates `b`. - `//=` updates defined-or paths using jq assignment semantics. - Short-circuiting must prevent unnecessary error-producing branches where jq requires it. ## Programmatic Acceptance === AC flow-002-conformance === Intent: The Boolean and alternative operator implementation passes every selected conformance case containing the owned operators. Suite: scoped Requires: executable=python3; scope=test import json import os import subprocess import sys select = r"and|or|not|//" result = subprocess.run( [sys.executable, "sources/run_conformance.py", "--select", select, "--json"], capture_output=True, text=True, env={**os.environ, "JQ": f"{os.getcwd()}/jq"}, ) print(result.stdout) print(result.stderr, file=sys.stderr) report = json.loads(result.stdout) summary = report["summary"] assert sum(summary.values()) > 0 assert summary["fail"] == 0 assert summary["error"] == 0 assert result.returncode == 0 === END AC flow-002-conformance === ## User Acceptance - None. ## Guardrails - Do not treat empty strings, arrays, or objects as falsey. - Preserve generator multiplicity and alternative fallback semantics. - Do not evaluate fallback branches when jq semantics select the left stream. === END ARTIFACT === Original FEATURE-Collection-Transformations.md, in the same form your reply must use: === BEGIN ARTIFACT FEATURE-Collection-Transformations.md === # FEATURE: Collection Transformations | Field | Value | |-------------|-------| | Version | 20260822 V1 | | Description | Provide jq collection transformation builtins with generator-preserving behavior. | | Depends On | FEATURE-Reductions-And-Iteration-Control.md, FEATURE-Deletion-And-Assignment.md, FEATURE-Type-And-Numeric-Primitives.md | | Provides | map, map_values, select, add, flatten, transpose, combinations, walk | | Consumes | generator evaluator, operators, path mutation | ## Workflow Collection filters transform arrays and objects while preserving jq stream order and multiplicity. Implement `map`, `map_values`, `select`, `add`, `flatten`, `transpose`, `combinations`, and recursive `walk` using the established evaluator and immutable update semantics. Empty generators, nested arrays, jagged matrices, and recursive values must follow the manual and `sources/builtin.jq`. ## Programmatic Acceptance === AC data-001-conformance === Intent: The authoritative corpus slice covering collection transformations executes and passes. Suite: scoped Requires: executable=python3; scope=test import json import os import subprocess import sys selector = r"map|flatten|transpose|combinations|walk" result = subprocess.run( [sys.executable, "sources/run_conformance.py", "--select", selector, "--json"], capture_output=True, text=True, env={**os.environ, "JQ": f"{os.getcwd()}/jq"}, ) print(result.stdout) print(result.stderr, file=sys.stderr) report = json.loads(result.stdout) summary = report["summary"] assert sum(summary.values()) > 0 assert summary["fail"] == 0 assert summary["error"] == 0 assert result.returncode == 0 === END AC data-001-conformance === ## User Acceptance - None. ## Guardrails - Preserve generator ordering, multiplicity, and backtracking. - Do not mutate input values in place. - Use only Python standard-library facilities. === END ARTIFACT === Original FEATURE-Complex-Assignment-Edges.md, in the same form your reply must use: === BEGIN ARTIFACT FEATURE-Complex-Assignment-Edges.md === # FEATURE: Complex Assignment Edges | Field | Value | |-------------|-------| | Version | 20260822 V1 | | Description | Defines edge-case behavior for iterated, empty, fractional, invalid, and deep assignments. | | Depends On | FEATURE-Deletion-And-Assignment.md, FEATURE-Path-Primitives.md | | Provides | Iterated path assignment, empty-update deletion, array expansion, assignment depth protections | | Consumes | Assignment operators, path primitives | ## Purpose Complete assignment semantics for complex path expressions and adversarial boundary cases. ## Implementation Requirements - Apply assignments across iterated and multi-path selections in generator order. - Treat an update producing `empty` as deletion. - Expand arrays with `null` values when setting beyond their current length. - Handle negative, fractional, NaN, and out-of-range indexes according to jq semantics. - Reject invalid string updates and invalid array path components with runtime errors. - Enforce assignment path depth limits. - Preserve partial output behavior when a later assignment fails. ## Programmatic Acceptance === AC complex-assignment-conformance === Intent: The authoritative corpus slice covering complex assignment edge cases executes and passes. Suite: scoped Requires: executable=python3; scope=test import json import os import subprocess import sys select = r"negative|NaN|depth|empty" result = subprocess.run( [sys.executable, "sources/run_conformance.py", "--select", select, "--json"], capture_output=True, text=True, env={**os.environ, "JQ": f"{os.getcwd()}/jq"}, ) print(result.stdout) print(result.stderr, file=sys.stderr) report = json.loads(result.stdout) summary = report["summary"] assert sum(summary.values()) > 0 assert summary["fail"] == 0 assert summary["error"] == 0 assert result.returncode == 0 === END AC complex-assignment-conformance === ## User Acceptance - None. ## Guardrails - Do not silently clamp invalid assignment indexes when jq specifies an error. - Do not discard valid outputs produced before a later runtime failure. - Do not exceed configured path depth limits through recursive or iterated assignments. === END ARTIFACT === Original FEATURE-Composition-And-Cartesian-Evaluation.md, in the same form your reply must use: === BEGIN ARTIFACT FEATURE-Composition-And-Cartesian-Evaluation.md === # FEATURE: Composition and Cartesian Evaluation | Field | Value | |-------------|-------| | Version | 20260822 V1 | | Description | Implement jq composition, Cartesian argument evaluation, collection, object construction, and binary filter composition. | | Depends On | FEATURE-Generator-Core.md, FEATURE-Filter-Grammar.md | | Provides | Pipes, commas, Cartesian arguments, arrays, objects, and binary filter composition | | Consumes | Generator core, parsed expressions, JSON value model | ## Scope Composition shall feed every output of a left-hand filter into the right-hand filter, concatenate comma streams in order, evaluate multi-output arguments as Cartesian products, and collect all generated values for arrays and objects. Binary operators shall receive independently evaluated filter results according to jq semantics. ## Programmatic Acceptance === AC composition-conformance === Intent: The authoritative corpus slice exercising pipes, commas, arrays, objects, indexing syntax, and binary composition executes and passes with no failures or errors. Suite: scoped Requires: executable=python3; scope=test import json import os import subprocess import sys select = r"\||,|\[|\{" result = subprocess.run( [sys.executable, "sources/run_conformance.py", "--select", select, "--json"], capture_output=True, text=True, env={**os.environ, "JQ": f"{os.getcwd()}/jq"}, ) print(result.stdout) print(result.stderr, file=sys.stderr) report = json.loads(result.stdout) summary = report["summary"] assert sum(summary.values()) > 0 assert summary["fail"] == 0 and summary["error"] == 0 assert result.returncode == 0 === END AC composition-conformance === === AC composition-cartesian-streams === Intent: The selected composition cases complete successfully with no failed or errored cases, covering stream ordering and Cartesian products. Suite: scoped Requires: executable=python3; scope=test import json import os import subprocess import sys select = r"\||,|\[|\{" result = subprocess.run( [sys.executable, "sources/run_conformance.py", "--select", select, "--json"], capture_output=True, text=True, env={**os.environ, "JQ": f"{os.getcwd()}/jq"}, ) report = json.loads(result.stdout) summary = report["summary"] assert summary["pass"] + summary["fail"] + summary["error"] + summary["skip"] > 0 assert summary["fail"] == 0 and summary["error"] == 0 assert result.returncode == 0 === END AC composition-cartesian-streams === ## User Acceptance - None. ## Guardrails - Preserve left-to-right generator ordering. - Evaluate every multi-output argument combination required by jq. - Array and object construction must collect generated values without dropping or duplicating outputs. === END ARTIFACT ===