Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@central/processindicator_jsonb/store/postgres/bench_test.go`:
- Around line 237-247: The NoSerialized benchmark currently uses
noSerializedStore.New(db.DB) which creates a store without a ChildFetcher so
nSt.Get and GetMany only return parent records; change the benchmark to either
instantiate the no-serialized store with the same ChildFetcher used in the other
benchmarks (i.e., construct the store with the child fetcher and use that
instance in the NoSerialized sub-bench) or add a new sub-benchmark (e.g.,
"NoSerialized+Children") that uses noSerializedStore.New(db.DB, ChildFetcher:
<existing child fetcher>) and performs the same Get/GetMany loops (using
noSerializedIDs and seedCount) so the LineageInfo is populated and the
comparison to Serialized/Jsonb is apples-to-apples.

In `@central/processindicator_jsonb/store/postgres/pg_internals_test.go`:
- Around line 65-98: The test is only measuring the parent table
"process_indicator_no_serializeds" and omits its child table
"process_indicator_no_serializeds_lineage_infos", underreporting sizes/counts;
update the queries in pg_internals_test.go (the loop that builds sizeResult and
the separate block for lineage) so that when tbl ==
"process_indicator_no_serializeds" you aggregate both tables (e.g., use
pg_total_relation_size on each table and sum, or use a single query that SELECTs
pg_total_relation_size('parent')+pg_total_relation_size('parent_lineage_infos')
AS total and similarly sum pg_table_size and pg_indexes_size and COUNT(*) from
both tables) and populate r.totalSize/r.tableSize/r.indexSize/r.rowCount
accordingly, or alternatively change the logged label to explicitly state
"parent-table-only" where you do not aggregate; apply the same change to the
later block that currently queries
process_indicator_no_serializeds_lineage_infos so the reported footprint
represents the complete no-serialized footprint.

In `@central/processindicator_no_serialized/store/postgres/bench_test.go`:
- Around line 495-507: The benchmark is measuring parent-only reads twice
because nSt (created via New(db.DB)) lacks a ChildFetcher, so the
"WithChildFetch" sub-benchmarks end up using the same no-child semantics as
nStNoChildren; fix by ensuring one store is constructed with a real child
fetcher: create the child-enabled store by passing the ChildFetcher (e.g.,
NoSerializedStoreOpts{ChildFetcher: FetchChildren} or the equivalent option)
when constructing the store used for "WithChildFetch" (symbols to update: New,
nSt, pgSearch.NewNoSerializedStore, nStNoChildren,
NoSerializedStoreOpts{ChildFetcher: FetchChildren}, FetchChildren), and apply
the same change in the other affected block around lines 550-560.

In `@central/processindicator_no_serialized/store/postgres/store.go`:
- Around line 231-244: The COPY generator increments idx before writing it to
the row, causing an off-by-one shift (first lineage row written with idx=1). In
the pgx.CopyFromFunc closure (inputRows) change the order so the current index
is used for the row (use idx or a local rowIdx := idx) and only then increment
idx (or increment after returning the row) so COPY produces the same 0-based
ordering as the batched/un-nest paths; update references to
procesIndicatorNoSerializedID, idx, and pgx.CopyFromFunc accordingly.

In `@pkg/postgres/schema/process_indicator_jsonbs.go`:
- Around line 32-35: The code is using an anonymous numeric cast
v1.SearchCategory(86) in the SetOptionsMap and RegisterCategoryToTable calls,
which lacks a corresponding named enum value in the proto definitions and makes
the code brittle. Add a new named SearchCategory constant to
proto/api/v1/search_service.proto file, then replace both instances of the raw
v1.SearchCategory(86) cast in the SetOptionsMap and RegisterCategoryToTable
function calls within the process_indicator_jsonbs.go file with the new named
constant instead of the magic number.

In `@pkg/postgres/schema/process_indicator_no_serializeds.go`:
- Around line 37-41: The code registers ProcessIndicatorNoSerialized schema
under an unnamed enum value v1.SearchCategory(85); update the registration to
use a real declared enum constant (e.g., replace v1.SearchCategory(85) with the
appropriate generated enum like v1.SearchCategory_<NAME>) or, if this is only
for tests, remove mapping.RegisterCategoryToTable and the SetOptionsMap call for
production code and keep the schema confined to test-only wiring; look for
symbols ProcessIndicatorNoSerialized, v1.SearchCategory(85),
schema.SetOptionsMap, and mapping.RegisterCategoryToTable to make the change and
ensure the chosen enum exists in generated/api/v1/search_service.pb.go before
committing.

In `@pkg/postgres/walker/walker.go`:
- Around line 422-429: The InlinedSubMessage being appended only stores
FieldName as structField.Name, which loses the full nested access path and
breaks initializer generation; change the appended data so FieldName (or a new
Path field) contains the full assignment path using ctx.Getter(structField.Name)
(or combine GetterPrefix and FieldName) instead of just structField.Name, so
schema.Root().InlinedSubMessages entries provide the complete nested access
expression for codegen (refer to InlinedSubMessage, FieldName, GetterPrefix,
ctx.Getter, and structField.Name).

In `@pkg/search/postgres/no_serialized_store.go`:
- Around line 44-45: fetchChildren currently invokes the fetcher with s.db which
causes child queries to bypass any transaction stored in ctx; update
fetchChildren (and the similar calls around the 159-164 region) to extract the
transactional DB from ctx (the same DB used by Get/GetMany/GetByQuery) and pass
that DB into the ChildFetcher[T] instead of s.db so child queries run inside the
active transaction; locate usages of fetchChildren and the call site where
ChildFetcher is invoked and replace s.db with the DB obtained from the ctx
transaction helper (or fall back to s.db only if no tx exists).

In `@tools/generate-helpers/pg-table-bindings/funcs.go`:
- Around line 329-344: The file has formatting issues around the template helper
block (notably the getterToSetter anonymous function and nearby helpers like
joinPath and stripPointer) causing golangci-lint/gofmt failures; fix by running
gofmt (or go fmt) on tools/generate-helpers/pg-table-bindings/funcs.go to
reformat the block so the anonymous functions (getterToSetter, joinPath,
stripPointer) and their surrounding commas/indentation conform to gofmt rules,
then commit the modified file.

In `@tools/generate-helpers/pg-table-bindings/list.go`:
- Around line 99-100: The map entries using &storage.ProcessIndicatorJsonb{} and
&storage.ProcessIndicatorNoSerialized{} currently contain extra alignment spaces
that break gofmt/golangci-lint; open the map in list.go and remove the extra
spaces so each key:value pair uses normal Go spacing (e.g.
"&storage.ProcessIndicatorJsonb{}: resources.DeploymentExtension," and
"&storage.ProcessIndicatorNoSerialized{}: resources.DeploymentExtension,") then
run gofmt/golangci-lint to confirm formatting is fixed.

In `@tools/generate-helpers/pg-table-bindings/store.go.tpl`:
- Around line 524-539: FetchChildren assumes a single UUID parent key and builds
objsByID as map[string]*storeType, ids []string, and the SQL uses
ANY($1::uuid[]) with only one query argument; to fix, make FetchChildren handle
arbitrary primary key types and composite keys by (1) changing the in-memory key
map to use the actual primary key tuple type returned by pkGetter (or serialize
composite keys consistently), (2) building a parameter slice matching the number
of parent key columns in FieldsReferringToParent and passing one argument per
column to db.Query, (3) removing the hard-coded ::uuid[] cast and instead use
appropriate type casts or parameter binding based on each parent PK column type,
and (4) update the SQL q construction and the call to db.Query (the q variable
and rows, err := db.Query(ctx, q, ...)) to supply the correct number and form of
arguments so composite and non-UUID parents work correctly.
- Around line 425-444: The bulk unnest loop can panic when a parent nested
message or an individual child is nil because it dereferences obj.{{
getterToSetter $child.ObjectGetter }} and child.* directly; update the loop that
iterates over objs and for childIdx, child := range obj.{{ getterToSetter
$child.ObjectGetter }} to first check the parent submessage for nil (skip or
append nil-equivalents for all child arrays when parent is nil) and for each
child check if child == nil before accessing child.{{ joinPath (setterPath
$field) }}; when child is nil, append the appropriate zero/NULL placeholder (or
use the $singlePK.Getter "obj" for parent references) instead of dereferencing
so arr_child_{{ scanVarName $field }} remains safe for batch inserts.
- Around line 381-403: The JSONB unmarshalling currently uses
protojson.Unmarshal which rejects unknown fields; update both scanRow and
scanRows to use a tolerant unmarshal by calling
protojson.UnmarshalOptions{DiscardUnknown:true}.Unmarshal(data, msg) (replace
protojson.Unmarshal(data, msg)), referencing the functions scanRow and scanRows
and the storeType message so the JSONB rows tolerate unknown future fields
during rolling upgrades.

---

Nitpick comments:
In `@tools/generate-helpers/pg-table-bindings/main.go`:
- Around line 181-188: The flags props.NoSerialized and props.Jsonb are mutually
exclusive but currently both can be set; validate and error early before
building walkOpts: in main (where walkOpts is constructed and walker.Walk is
called) add a check that if props.NoSerialized && props.Jsonb then return an
error/exit with a clear message; reference the variables props.NoSerialized,
props.Jsonb and the walk option helpers walker.WithNoSerialized /
walker.WithJsonb so the validation occurs before creating walkOpts and calling
walker.Walk.