fix(loop): hydrate externalized node outputs before namespace construction - #286

Fixes #285.

Problem

Loop node results larger than LoopOutputInlineLimitBytes (16 KB) are externalized to
loop_output_blobs, and GenerationOutput.OutputRef then holds a sha256:… ref rather than the
payload. Nothing read that blob back. runtimeNamespace builds each node entry straight from the
ref:

entry["output"] = outputValue(output.OutputRef)

outputValue tries to parse the ref as JSON, fails, and returns the raw "sha256:…" string. Every
template reaching into that node's output then resolves against a hash.

Fan-out is where it fails loudly — resolveFanOutCollection cannot walk .output.tasks inside a
string, so the run dies with fan-out collection reference … is unavailable right after its producer
succeeded. Gate criteria, action params and prompt templates degrade silently through the same path.

This breaks the first-party dev-cycle software-delivery Loop for realistic inputs: load_tasks
inlines each task's full markdown body, so four ordinary task files produced a 41 KB output and the
fan-out driving the whole delivery could not resolve.

Change

Resolve content-addressed refs into their payloads immediately after the coordinator loads generation
outputs, so externalization stays a storage detail instead of something every consumer must know
about.

The read side already existed and was simply never wired — getLoopOutputByRefWithExecutor had no
production caller, and ErrOutputRefNotFound was already defined for exactly this. This exposes it
as LoopRepo.GetGenerationOutputPayload, adds it to GenerationOutputReader, and calls it from
hydrateGenerationOutputs.

Two properties worth calling out:

• Fan-out materializations are covered too. A materialization carrying large items exceeds the
  limit itself and becomes a blob, which would break fanOutItem serving .item to the fan-out
  body. Hydrating at the load site fixes the collection and .item in one place; fixing only
  resolveFanOutCollection would have failed at the next step.
• The HTTP surface is unchanged. Hydration is scoped to the two coordinator load sites rather
  than to LoopRepo.ListGenerationOutputs, so GET /loop-runs/:id keeps returning refs instead of
  inlining full payloads into API responses.

output_ref already holds either inline JSON or a ref depending on size, so replacing a ref with
its payload restores the invariant outputValue has always assumed rather than introducing new
semantics.

Scope

Read-path only. The write path (OutputPayloadRequiresRef, writeGenerationOutputBlob) and the
16 KB limit itself are untouched — the limit is a reasonable inline cap that was just missing its
matching read.

Tests

internal/loop/generation_output_hydration_test.go covers:

• a content-addressed ref replaced by its payload
• inline outputs passing through with no blob lookup
• one lookup per distinct ref when several outputs share a payload
• a missing blob surfacing ErrOutputRefNotFound instead of degrading to the ref
• a regression asserting the fan-out collection reference is unavailable before hydration and
  resolves to its items after

go test ./internal/loop/...
ok  github.com/compozy/compozy/internal/loop
ok  github.com/compozy/compozy/internal/loop/dsl
ok  github.com/compozy/compozy/internal/loop/dsl/refs
ok  github.com/compozy/compozy/internal/loop/gate
ok  github.com/compozy/compozy/internal/loop/goal
ok  github.com/compozy/compozy/internal/loop/watch

go vet ./internal/loop/... ./internal/store/globaldb/... ./internal/daemon/... is clean, as is
gofmt.

Verification against the reported failure

The 16 KB boundary was measured by running software-delivery in a throwaway workspace against a
synthetic task file of increasing size and reading back loop_generation_outputs.output_ref: outputs
of 2 713 B / 9 789 B / 15 822 B stayed inline and ran, while 18 142 B / 19 302 B became blobs and
failed. Details in #285.

I have not been able to run the full repository suite locally (the sandbox only has the Go packages
checked out), so CI is the real signal for anything outside internal/loop.