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

Inline comments:
In `@internal/agent/snapshot.go`:
- Around line 422-427: The code silently ignores errors from the resolve
function in the r.walk path, causing BuildSnapshotForDAG to miss nested agent
steps; change r.walk (and its callers, including BuildSnapshotForDAG) to return
an error and, where resolve != nil, if resolve(ctx, target) returns a non-nil
err then return that error instead of skipping the branch; keep the existing
behavior only when resolve == nil (no-op), but ensure all call sites propagate
the returned error up so sub-DAG resolution failures surface during snapshot
planning.
- Around line 207-215: The snapshot currently uses reqs.sortedDAGNames() when
needsMemory is set by step.Agent.Memory.Enabled, which pulls memory from all
visited DAGs; instead track DAGs that opted into agent memory separately (e.g.,
build a reqs.memoryDAGNames or reqs.sortedMemoryDAGNames() collection while
evaluating step.Agent.Memory.Enabled) and pass that collection into
snapshotMemory(ctx, stores.MemoryStore, reqs.sortedMemoryDAGNames()) so
snapshot.Memory only contains DAG-scoped memory that explicitly enabled agent
memory; apply the same change wherever snapshotMemory or memory population is
invoked (the other occurrences referenced around the later blocks) and ensure
needsMemory remains driven by step.Agent.Memory.Enabled but uses the new
memory-specific name list for extraction and snapshot.Memory assignment.
- Around line 258-268: The helpers snapshotSkills and snapshotSouls currently
treat ErrSkillNotFound/ErrSoulNotFound as success and skip missing entries;
change them to fail-fast by returning an error when store.GetByID returns
ErrSkillNotFound or ErrSoulNotFound instead of continuing. Update the
switch/default branches in snapshotSkills (handling SkillStore.GetByID and
ErrSkillNotFound) and the analogous logic in snapshotSouls (SoulStore.GetByID
and ErrSoulNotFound) to return a descriptive wrapped error (e.g.,
fmt.Errorf("load skill %q for snapshot: %w", id, ErrSkillNotFound)) so the
caller sees missing references rather than producing an incomplete snapshot.
- Around line 106-117: The gzip decode path currently uses io.ReadAll(zr) which
allows decompressed data to grow unbounded; replace that with a bounded read
using an io.LimitedReader (or io.LimitReader) and a package-level constant like
maxUncompressedSnapshotSize to cap the decompressed size in the function that
opens the gzip reader (the block using gzip.NewReader and variable zr). Read up
to maxSize+1 bytes so you can detect overflow, and if the read returns more than
maxUncompressedSnapshotSize, return a clear error (e.g., "agent snapshot too
large"); ensure zr is still closed in the defer and propagate other read errors
as before.

In `@internal/agent/system_prompt.txt`:
- Around line 59-64: The template emits <memory_paths> even when Memory.ReadOnly
is true, which contradicts the read-only contract; update
internal/agent/system_prompt.txt to render the <memory_paths> section only when
MemoryDir is set AND Memory.ReadOnly is false (i.e., wrap the <memory_paths>
block in a conditional that checks !Memory.ReadOnly), leaving the existing
<memory_mode> block for the read-only notice intact so the prompt advertises no
writable memory targets during snapshot-backed runs.

In `@internal/service/scheduler/dag_executor.go`:
- Around line 255-262: The buildSnapshotBuilder function currently returns nil
when dagStore is nil, disabling snapshot creation; instead always return the
closure that calls agentsnapshot.BuildFromPaths so BuildFromPaths can handle a
nil dagStore itself—update buildSnapshotBuilder (the returned anonymous func) to
be returned unconditionally and simply call agentsnapshot.BuildFromPaths(ctx,
dag, paths, dagStore) even when dagStore is nil.

---

Nitpick comments:
In `@internal/runtime/executor/task.go`:
- Around line 116-121: WithAgentSnapshot currently assigns the incoming []byte
directly to coordinatorv1.Task.AgentSnapshot which can leak mutations; change
WithAgentSnapshot to defensively copy the snapshot (handle nil by setting nil)
before assigning so the Task holds its own byte slice (e.g., allocate a new
[]byte of len(snapshot) and copy into it) to prevent caller-side mutations from
affecting the task.

In `@internal/service/scheduler/scheduler.go`:
- Around line 116-119: The current code casts er to *entryReaderImpl to grab
impl.dagStore which hides a dependency and breaks snapshot enrichment for other
EntryReader implementations; change newScheduler to accept an exec.DAGStore
parameter (or add a DAGStore() exec.DAGStore method to the EntryReader
interface) and use that explicit DAGStore inside newScheduler/scheduler
construction instead of the type assertion, updating call sites that construct
the scheduler to pass the DAGStore through.