fix(jq): preserve integer precision with json.Number

Decode the API response for --jq with a json.Decoder in UseNumber mode so
integer ids beyond 2^53 survive as json.Number instead of being rounded to
float64. gojq accepts json.Number input and normalizes it to int/*big.Int,
so large ids pass through exactly and arithmetic still works.

Add a regression test asserting a large id (123456789012345678) is emitted
exactly, and update the README precision note to match the fixed behavior.

Author: a68366

README.md

@@ -74,9 +74,9 @@ typed command:
 string prints raw and unquoted (pipe-friendly); any other result (object,
 array, number, bool, null) prints as compact JSON, one result per line. An
 invalid expression is rejected before any request is made. The jq engine is
-embedded in `pfix` — no external `jq` binary is required. Numbers are processed
-as floating-point (the jq number model), so integers beyond 2^53 may lose
-precision under `--jq`; use plain `--json` when you need exact large numbers.
+embedded in `pfix` — no external `jq` binary is required. Integer values,
+including ids beyond 2^53, are preserved exactly through `--jq`; fractional
+numbers follow jq's usual number model.
 
 **Filtering lists.** The `list` commands for `task`, `project`, `contact`, `user`,
 `report`, `datatag`, and `object` accept `--filter <json>` — a raw Planfix filters

internal/output/jq.go

@@ -1,6 +1,7 @@
 package output
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -32,8 +33,14 @@ func EmitJSON(w io.Writer, raw []byte, jqExpr string) error {
 	if err != nil {
 		return err
 	}
+	// Decode with UseNumber so integer ids beyond 2^53 survive as json.Number
+	// instead of being rounded to float64. gojq accepts json.Number input and
+	// normalizes it to int/*big.Int, so large ids pass through exactly and
+	// arithmetic still works.
 	var input any
-	if err := json.Unmarshal(raw, &input); err != nil {
+	dec := json.NewDecoder(bytes.NewReader(raw))
+	dec.UseNumber()
+	if err := dec.Decode(&input); err != nil {
 		return fmt.Errorf("--jq: response is not valid JSON: %w", err)
 	}
 	iter := q.Run(input)

internal/output/jq_test.go

@@ -56,6 +56,11 @@ func TestEmitJSONFiltered(t *testing.T) {
 		{"object result compact", `{"tasks":[{"name":"a"}]}`, ".tasks[0]", "{\"name\":\"a\"}\n"},
 		{"missing key yields null", `{}`, ".missing", "null\n"},
 		{"empty result set", `{"tasks":[]}`, ".tasks[]", ""},
+		// Large integer ids (beyond 2^53) must survive exactly, not round to a
+		// float. 123456789012345678 would become 123456789012345680 under a
+		// float64 decode; json.Number keeps it intact.
+		{"large integer id preserved", `{"task":{"id":123456789012345678}}`, ".task.id", "123456789012345678\n"},
+		{"large integer arithmetic exact", `{"task":{"id":123456789012345678}}`, ".task.id + 1", "123456789012345679\n"},
 	}
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {