atom-agent 1.2.0 → 1.4.0

package/dist/providers.js

@@ -68,7 +68,7 @@ export const PROVIDERS = [
             "minimax-m2.7",
             "big-pickle",
         ],
-        notes: "OpenAI-compatible chat/completions. reasoning_effort only here.",
+        notes: "OpenAI-compatible chat/completions. /effort sends reasoning_effort (Auto omits it).",
         cache: {
             explicitBreakpoints: false,
             implicitPrefix: true,
@@ -90,7 +90,7 @@ export const PROVIDERS = [
             "gpt-5.6-terra",
             "gpt-5.6-luna",
         ],
-        notes: "OpenAI-compatible chat/completions. reasoning_effort never sent.",
+        notes: "OpenAI-compatible chat/completions. /effort sends reasoning_effort (Auto omits it).",
         cache: {
             explicitBreakpoints: false,
             implicitPrefix: true,
@@ -112,7 +112,7 @@ export const PROVIDERS = [
             "claude-3-5-sonnet-20241022",
             "claude-3-5-haiku-20241022",
         ],
-        notes: "Messages API with tool_use blocks. max_tokens 4096.",
+        notes: "Messages API with tool_use blocks. max_tokens 4096. /effort maps to the thinking budget (Auto omits it).",
         cache: {
             explicitBreakpoints: true,
             implicitPrefix: true,
@@ -134,7 +134,7 @@ export const PROVIDERS = [
             "deepseek-v4-flash",
             "deepseek-v4-pro",
         ],
-        notes: "OpenAI-compatible (no /v1 prefix). reasoning_effort never sent.",
+        notes: "OpenAI-compatible (no /v1 prefix). /effort sends reasoning_effort (Auto omits it).",
         cache: {
             explicitBreakpoints: false,
             implicitPrefix: true,
@@ -156,7 +156,7 @@ export const PROVIDERS = [
             "mistral-small-latest",
             "open-mistral-nemo",
         ],
-        notes: "OpenAI-compatible chat/completions. reasoning_effort never sent.",
+        notes: "OpenAI-compatible chat/completions. /effort sends reasoning_effort (Auto omits it).",
         cache: {
             explicitBreakpoints: false,
             implicitPrefix: false,
@@ -179,7 +179,7 @@ export const PROVIDERS = [
             "gemini-2.0-flash",
             "gemini-1.5-flash",
         ],
-        notes: "streamGenerateContent SSE; :generateContent fallback.",
+        notes: "streamGenerateContent SSE; :generateContent fallback. /effort maps to thinkingLevel (Auto omits it; Max rides high).",
         cache: {
             explicitBreakpoints: false,
             implicitPrefix: true,

package/dist/scheduler.js

@@ -1,11 +1,16 @@
-// Effect-aware tool scheduler: data-driven parallelism without Promise.all-
-// ing every tool.
+// Effect-aware tool scheduler: data-driven parallelism, parallel by default.
 //
 // The contract: batchable calls run concurrently, conflicting calls stay
 // serialized, results commit in original call order, cancel stops between
 // batches, approval happens per call in order before execution. This module
 // only PLANS batches; execution (agent/loop.ts runLoopWithChat) is untouched.
 //
+// Parallel-by-default posture: side-effect-free reads batch unconditionally
+// (same target included — two reads can never race each other); only real
+// conflicts serialize: same-file write order, read/write on the same file,
+// invisible footprints (bash), shared ambient state (todos), interactive
+// prompts, and calls the planner cannot see (unknown/malformed/invalid).
+//
 // How it reasons (per tool, from the TOOL_EFFECTS table — the single
 // coupling point; the algorithm below has no per-tool branches):
 // - missing metadata → serial singleton (new tools fail safe, like the old
@@ -22,17 +27,18 @@
 //   (see canonicalFileKey): same-file mutations never share a batch, so they
 //   stay strictly ordered in program order; different files run concurrently.
 //   An unresolvable target stays serial (never batch what you cannot see).
-// - reads batch with pairwise-disjoint keys, where the key is tool + target.
-//   Same tool + same target serializes (the old overlap rule, kept verbatim:
-//   e.g. two reads of one path). A path read also conflicts with an open
-//   write to the same canonical file (read-after-write stays ordered), and a
-//   write conflicts with any open member on its key (write-after-read stays
-//   ordered). Directory-scoped scans (grep/glob) vs concurrent writes to
-//   unscanned-listed files are out of scope — same exposure as an editor
-//   saving mid-scan; only same-canonical-path pairs are ordered.
-// - deterministic is declared per tool; its current enforcement is the
-//   same-key rule (a re-poll of the same background task, whose output can
-//   grow, never runs concurrently with itself).
+// - reads (filesystem or network) always batch: a pure read has no observable
+//   footprint, so even the same tool + same target runs concurrently. A path
+//   read against an open write to the same canonical file still stays ordered
+//   (read-after-write): it splits the batch — and a write conflicts with any
+//   open read on its key (write-after-read stays ordered). Directory-scoped
+//   scans (grep/glob) vs concurrent writes to unscanned-listed files are out
+//   of scope — same exposure as an editor saving mid-scan; only
+//   same-canonical-path pairs are ordered.
+// - deterministic is informational only (same output for same args); it no
+//   longer drives batching — not even same-task bash_output polls serialize,
+//   since concurrent polls are side-effect-free reads whose results commit in
+//   call order anyway.
 //
 // Pure module except the shared arg validators (same imports zen.ts already
 // carries — no new coupling class) plus best-effort path canonicalization
@@ -43,7 +49,7 @@
 // tests/parallel-writes.test.ts.
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { toolNames, validateToolArgs } from "./tools.js";
+import { isCustomTool, toolExecutionMode, toolNames, validateToolArgs } from "./tools.js";
 const str = (v) => (typeof v === "string" ? v : "");
 const targetOf = (key) => (args) => {
     const t = str(args[key]);
@@ -93,8 +99,8 @@ export const TOOL_EFFECTS = {
         process: "none",
         interactive: false,
         exclusive: false,
-        // Live search results vary call to call; same-query conflict is still
-        // serialized by the same-key rule.
+        // Live search results vary call to call; concurrent same-query searches
+        // are merely redundant, never incorrect — reads always batch.
         deterministic: false,
         target: targetOf("query"),
     },
@@ -105,8 +111,8 @@ export const TOOL_EFFECTS = {
         process: "none",
         interactive: false,
         exclusive: false,
-        // A running task's output grows between polls — same-task polls
-        // serialize via the same-key rule.
+        // A running task's output grows between polls — concurrent same-task
+        // polls are side-effect-free reads whose results commit in call order.
         deterministic: false,
         target: targetOf("taskId"),
     },
@@ -213,27 +219,55 @@ export function canonicalFileKey(rawPath, cwd = process.cwd()) {
     return abs;
 }
 // Partition one assistant message's tool_calls into commit batches,
-// preserving program order: consecutive batchable calls with pairwise
-// disjoint keys form one batch; any serial-only call — and any call whose
-// key already appears in the open batch — closes the batch and runs as a
-// strict serial singleton. Filesystem writes join a batch only on a
-// disjoint canonical file key (same-file mutations split into sequential
-// batches, never concurrent); a path read conflicting with an open write —
-// or a write conflicting with any open member — on the same canonical key
-// also splits, so per-file program order always holds. A later batch never
+// preserving program order: consecutive batchable calls form one batch; any
+// serial-only call closes the batch and runs as a strict serial singleton.
+// Filesystem writes join a batch only on a disjoint canonical file key
+// (same-file mutations split into sequential batches, never concurrent); a
+// path read conflicting with an open write — or a write conflicting with any
+// open member — on the same canonical key also splits, so per-file program
+// order always holds. Reads never split on each other. A later batch never
 // moves ahead of an earlier serial call, and batches never span the block
 // boundary.
 export function planBatches(calls) {
     const batches = [];
     let open = [];
-    const keys = new Set();
     // Canonical file keys of the open batch ("read" and/or "write" per key).
+    // This is the ONLY cross-call ordering state: same-file read/write pairs
+    // stay in program order; everything else batches freely.
     const openFiles = new Map();
+    // Lenient parse for classification/fallback only (mirrors the loop: {}
+    // when the JSON is malformed — the error result commits downstream).
+    const lenientParse = (call) => {
+        try {
+            const raw = call?.function?.arguments ?? "{}";
+            const v = JSON.parse(typeof raw === "string" ? raw : "{}");
+            return typeof v === "object" && v !== null ? v : {};
+        }
+        catch {
+            return {};
+        }
+    };
+    // Extension sequential hint (ticket 06): a tool declaring sequential
+    // execution forces its whole sibling batch one-at-a-time (Pi-style). This
+    // only ever ADDS serialization — same-file order, bash/todo/prompt
+    // isolation, ordered commits, and the approval pre-pass are untouched
+    // (singletons satisfy every one of them; the loop below handles them
+    // exactly as before, one call per batch).
+    if (calls.some((call) => {
+        const name = typeof call?.function?.name === "string" ? call.function.name : "";
+        try {
+            return toolExecutionMode(name) === "sequential";
+        }
+        catch {
+            return false;
+        }
+    })) {
+        return calls.map((call) => [{ call, parsed: lenientParse(call), parallelKey: null }]);
+    }
     const flush = () => {
         if (open.length > 0) {
             batches.push(open);
             open = [];
-            keys.clear();
             openFiles.clear();
         }
     };
@@ -254,6 +288,15 @@ export function planBatches(calls) {
             malformed = true;
         }
         const name = typeof call?.function?.name === "string" ? call.function.name : "(unknown)";
+        // Extension tools carry no scheduler effect metadata: their footprint is
+        // invisible, so they always run as serial singletons (fail safe, exactly
+        // like the old allowlist-miss). Batch planning is never corrupted by
+        // what it cannot see; validation still runs in the loop, where failures
+        // become inline-error results.
+        if (isCustomTool(name)) {
+            singleton(call, parsed);
+            continue;
+        }
         // Missing metadata fails safe to serial (never batch the unknown).
         const meta = TOOL_EFFECTS[name];
         if (malformed || !meta || !toolNames().includes(name)) {
@@ -287,8 +330,9 @@ export function planBatches(calls) {
             open.push({ call, parsed, parallelKey: `${name} ${fileKey}` });
             continue;
         }
-        // Reads batch on disjoint tool+target keys; empty target = unknown
-        // footprint = serial.
+        // Reads always batch (parallel by default): a pure read has no
+        // observable footprint, so even the same tool + same target runs
+        // concurrently. Empty target = unknown footprint = serial.
         let target = null;
         try {
             target = meta.target(parsed);
@@ -301,10 +345,6 @@ export function planBatches(calls) {
             continue;
         }
         const key = `${name} ${target}`;
-        if (keys.has(key)) {
-            singleton(call, parsed);
-            continue;
-        }
         // A path read against an open write to the same canonical file stays
         // ordered (read-after-write): split the batch.
         if (name === "read") {
@@ -313,13 +353,11 @@ export function planBatches(calls) {
                 singleton(call, parsed);
                 continue;
             }
-            keys.add(key);
             if (fileKey && !openFiles.has(fileKey))
                 openFiles.set(fileKey, "read");
             open.push({ call, parsed, parallelKey: key });
             continue;
         }
-        keys.add(key);
         open.push({ call, parsed, parallelKey: key });
     }
     flush();

package/dist/session.js

@@ -6,10 +6,13 @@
 // cannot corrupt or clobber the last good save.
 //
 // Shape: {version:1, savedAt, provider, model, effort, mode, usageTotals,
+// goal (ticket 07: the live session goal plus cumulative stats, or null),
 // history (full API history incl. system + tool pairs), turns (display
 // transcript)}. Writes are atomic (temp file + rename) to survive kills
 // mid-write. Loads never throw: missing -> "missing", anything malformed ->
-// "corrupt" (caller shows a one-line notice and starts fresh).
+// "corrupt" (caller shows a one-line notice and starts fresh). A missing or
+// corrupt goal degrades to no-goal (null) WITHOUT failing the load — the
+// conversation still restores.
 //
 // Privacy: the file can contain pasted secrets if the user typed them as
 // chat. Never print its contents; never commit it (it lives under ~/.atom,
@@ -19,6 +22,7 @@ import * as path from "node:path";
 import { atomDir, getStoredBaseURL, loadAuth, resolveApiKey } from "./auth.js";
 import { chatEndpointFor, isProviderId, openaiCompatibleChatEndpoint, } from "./providers.js";
 import { EFFORT_OPTIONS, } from "./zen.js";
+import { restoreGoalFromPersist, serializeGoalForPersist, } from "./goal.js";
 export const SESSION_VERSION = 1;
 export const SESSION_FILENAME = "session.json";
 export function sessionFilePath(home) {
@@ -74,6 +78,9 @@ export function saveSession(snapshot, home) {
         effort: snapshot.effort,
         mode: snapshot.mode,
         usageTotals: snapshot.usageTotals,
+        // Piggyback: the live goal rides every completed-turn save (no new save
+        // cadence — compaction and clean exit flow through here too).
+        goal: serializeGoalForPersist(snapshot.goal ?? null),
         history: snapshot.history.map((m) => ({ ...m })),
         turns: snapshot.turns.map((t) => ({ ...t })),
     };
@@ -210,9 +217,16 @@ function validateSession(data) {
     const model = data["model"];
     if (!isNonEmptyString(model))
         return null;
-    const effort = data["effort"];
-    if (typeof effort !== "string" ||
-        !EFFORT_OPTIONS.includes(effort)) {
+    // "default" is the pre-auto name for the same level: old saves map to
+    // "auto" instead of failing the load.
+    const rawEffort = data["effort"];
+    const effort = rawEffort === "default"
+        ? "auto"
+        : typeof rawEffort === "string" &&
+            EFFORT_OPTIONS.includes(rawEffort)
+            ? rawEffort
+            : null;
+    if (effort === null) {
         return null;
     }
     const mode = data["mode"];
@@ -241,9 +255,13 @@ function validateSession(data) {
         savedAt,
         provider,
         model,
-        effort: effort,
+        effort,
         mode,
         usageTotals: validateUsageTotals(data["usageTotals"]),
+        // Tolerant: a trashed goal degrades to no-goal (null) without failing
+        // the load — the conversation still restores. Re-serialized so the
+        // loaded record always carries concrete stats.
+        goal: serializeGoalForPersist(restoreGoalFromPersist(data["goal"])),
         history: history,
         turns: turns,
     };

package/dist/sessions.js

@@ -19,18 +19,30 @@
 //   import LLM clients.
 // - No transient UI state (scroll, cursor, picker, queue) is stored.
 //
-// Import budget: value imports are node:fs, node:path, node:crypto and
-// ./auth.js only (type-only imports from ./zen.js / ./providers.js are
-// erased at compile, so the runtime DAG stays acyclic and React-free).
+// Import budget: value imports are node:fs, node:path, node:crypto,
+// ./auth.js, and ./goal.js (goal persistence-shape helpers only —
+// serialize/restore/validate; goal.js itself is React-free and imports no
+// session module, so the runtime DAG stays acyclic) plus type-only imports
+// from ./zen.js / ./providers.js / ./goal.js (erased at compile).
 import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
 import { randomUUID } from "node:crypto";
 import * as path from "node:path";
 import { atomDir } from "./auth.js";
+import { restoreGoalFromPersist, serializeGoalForPersist, } from "./goal.js";
 // Literal defaults for new sessions (opaque carried fields — see header).
 export const SESSION_DEFAULT_PROVIDER = "opencode-zen";
 export const SESSION_DEFAULT_MODEL = "";
-export const SESSION_DEFAULT_EFFORT = "default";
+export const SESSION_DEFAULT_EFFORT = "auto";
 export const SESSION_DEFAULT_MODE = "normal";
+// "default" is the pre-auto name for the same level: old records map to
+// "auto" on load/create instead of carrying a dead value. Local one-liner
+// (not imported from zen.js) to honor this module's import budget above.
+function canonicalSessionEffort(value) {
+    if (value === "low" || value === "medium" || value === "high" || value === "max") {
+        return value;
+    }
+    return "auto";
+}
 export const SESSIONS_DIRNAME = "sessions";
 export const ACTIVE_FILENAME = "active";
 export function sessionsDir(home) {
@@ -254,9 +266,13 @@ function validateSessionRecord(data) {
         cwd: data["cwd"],
         provider: data["provider"],
         model: data["model"],
-        effort: data["effort"],
+        effort: canonicalSessionEffort(data["effort"]),
         mode: data["mode"],
         usageTotals: validateUsageTotals(data["usageTotals"]),
+        // Tolerant: a missing or trashed goal reads as no-goal (null) — the
+        // record still loads, so one corrupt field can never strand a session.
+        // Re-serialized so the loaded record always carries concrete stats.
+        goal: serializeGoalForPersist(restoreGoalFromPersist(data["goal"])),
         history: history,
         turns: turns,
         metadata: isRecord(metadata) ? { ...metadata } : {},
@@ -311,11 +327,14 @@ export function createSession(opts = {}, home) {
         cwd: typeof opts.cwd === "string" ? opts.cwd : safeCwd(),
         provider: opts.provider ?? SESSION_DEFAULT_PROVIDER,
         model: opts.model ?? SESSION_DEFAULT_MODEL,
-        effort: opts.effort ?? SESSION_DEFAULT_EFFORT,
+        effort: canonicalSessionEffort(opts.effort ?? SESSION_DEFAULT_EFFORT),
         mode: opts.mode ?? SESSION_DEFAULT_MODE,
         usageTotals: opts.usageTotals === undefined || opts.usageTotals === null
             ? null
             : validateUsageTotals(opts.usageTotals),
+        // Fresh sessions start with no goal unless the caller restores one
+        // (tolerantly validated — corrupt input reads as no-goal, never throws).
+        goal: serializeGoalForPersist(restoreGoalFromPersist(opts.goal ?? null)),
         history: (opts.history ?? []).map((m) => ({ ...m })),
         turns: (opts.turns ?? []).map((t) => ({ ...t })),
         metadata: isRecord(opts.metadata) ? { ...opts.metadata } : {},

package/dist/telemetry-dashboard.js

@@ -243,6 +243,26 @@ function iterationTimeline(s) {
     });
     return `<div class="timeline">${rows.join("")}</div>`;
 }
+// Goal fragment for one turn (ticket 09): rendered only when the trace
+// carries a goal snapshot — absent or malformed reads as no-goal and renders
+// nothing (never a fake claim). Counters show only when reported.
+function goalFragment(t) {
+    const g = t.goal;
+    if (!g || typeof g.objective !== "string" || g.objective.length === 0)
+        return "";
+    const state = g.active === true ? "active" : "paused";
+    const bits = [];
+    if (typeof g.turns === "number")
+        bits.push(`${fmtCount(g.turns)} turn(s)`);
+    if (typeof g.requests === "number")
+        bits.push(`${fmtCount(g.requests)} request(s)`);
+    if (typeof g.tokens === "number")
+        bits.push(`${fmtCount(g.tokens)} tokens`);
+    if (typeof g.workMs === "number")
+        bits.push(fmtMs(g.workMs));
+    const counters = bits.length > 0 ? ` <span class="mute">(${bits.join(" · ")})</span>` : "";
+    return `<p><strong>Goal:</strong> <span class="mono">${escapeHtml(g.objective)}</span> <span class="pill">${state}</span>${counters}</p>`;
+}
 function turnBlock(t) {
     const outcomeCls = t.outcome === "completed" ? "ok" : t.outcome === "failed" ? "err" : "warn";
     const total = turnTokensTotal(t);
@@ -272,6 +292,7 @@ function turnBlock(t) {
     <summary><span class="mono">${escapeHtml(t.id)}</span> · ${fmtTime(t.startedAt)} · ${escapeHtml(t.provider)} · ${escapeHtml(t.model)} · ${head}</summary>
     <div class="turnbody">
       <p><strong>Input:</strong> <span class="mono">${escapeHtml(t.inputPreview)}</span> <span class="mute">(${fmtCount(t.inputChars)} chars)</span></p>
+      ${goalFragment(t)}
       ${t.error ? `<p><strong>Error:</strong> <span class="err">${escapeHtml(t.error)}</span></p>` : ""}
       ${t.replyPreview ? `<p><strong>Reply:</strong> <span class="mono">${escapeHtml(t.replyPreview)}</span></p>` : ""}
       <h5>Timeline</h5>
@@ -361,6 +382,12 @@ export function buildDashboardHtml(sessions, opts = {}) {
     const successRate = agg.toolSuccessRate !== null
         ? `${(agg.toolSuccessRate * 100).toFixed(1)}%`
         : `<span class="na" title="No tool calls recorded — a rate over zero calls would be fake.">n/a</span>`;
+    // Goal overview (ticket 09): present only when at least one stored turn
+    // carried a goal snapshot — zero goal turns omit the card entirely (same
+    // conditional-render precedent as the corrupt-file note above).
+    const goalCard = agg.goalTurns > 0
+        ? `<div class="card"><div class="k">Goal turns</div><div class="v">${fmtCount(agg.goalTurns)}</div></div>`
+        : "";
     const refreshSeconds = typeof opts.refreshSeconds === "number" && Number.isFinite(opts.refreshSeconds)
         ? Math.floor(opts.refreshSeconds)
         : 0;
@@ -504,6 +531,7 @@ ${corruptNote}
 <div class="card"><div class="k">Completion tokens (reported)</div><div class="v">${fmtTokens(agg.usage.completion_tokens, agg.usageReported, "No model call reported completion_tokens.")}</div></div>
 <div class="card"><div class="k">Cache read / write (reported)</div><div class="v">${fmtTokens(agg.usage.cacheReadTokens, agg.usageReported, "No provider reported cache-read counters.")} / ${fmtTokens(agg.usage.cacheWriteTokens, agg.usageReported, "No provider reported cache-write counters.")}</div></div>
 <div class="card"><div class="k">Retries</div><div class="v">${fmtCount(agg.retries)}</div></div>
+${goalCard}
 <div class="card"><div class="k">Read-cache hits (local)</div><div class="v">${fmtCount(agg.cacheHits)}</div></div>
 <div class="card"><div class="k">Loop-guard hits</div><div class="v">${fmtCount(agg.repetitionHits)}</div></div>
 <div class="card"><div class="k">Avg model latency</div><div class="v">${fmtMs(agg.avgModelLatencyMs)}</div></div>

package/dist/telemetry.js

@@ -111,6 +111,38 @@ export function cleanUsage(value) {
         ? out
         : undefined;
 }
+// Keep only a well-formed goal snapshot (tolerant reader/writer pair with
+// the dashboard: absent or malformed reads as no-goal, never a throw).
+// Returns undefined when no goal was live. The objective is capped so a
+// pasted paragraph cannot bloat the trace; counters copy finite values only.
+export function cleanGoalSnapshot(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const o = value;
+    const objective = o["objective"];
+    if (typeof objective !== "string" || objective.length === 0)
+        return undefined;
+    const snap = {
+        objective: objective.length > TELEMETRY_INPUT_PREVIEW_CHARS
+            ? objective.slice(0, TELEMETRY_INPUT_PREVIEW_CHARS)
+            : objective,
+        active: o["active"] === true,
+    };
+    const counter = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.floor(v) : undefined;
+    const turns = counter(o["turns"]);
+    if (turns !== undefined)
+        snap.turns = turns;
+    const requests = counter(o["requests"]);
+    if (requests !== undefined)
+        snap.requests = requests;
+    const tokens = counter(o["tokens"]);
+    if (tokens !== undefined)
+        snap.tokens = tokens;
+    const workMs = counter(o["workMs"]);
+    if (workMs !== undefined)
+        snap.workMs = workMs;
+    return snap;
+}
 export function addUsageInto(target, extra) {
     if (!extra)
         return false;
@@ -438,6 +470,7 @@ export function summarizeTelemetry(sessions) {
         retries: 0,
         cacheHits: 0,
         repetitionHits: 0,
+        goalTurns: 0,
         outcomes: emptyOutcomes(),
         byTool: [],
         avgModelLatencyMs: null,
@@ -462,6 +495,9 @@ export function summarizeTelemetry(sessions) {
                 agg.turns += 1;
                 if (t.outcome in agg.outcomes)
                     agg.outcomes[t.outcome] += 1;
+                if (t.goal && typeof t.goal.objective === "string" && t.goal.objective.length > 0) {
+                    agg.goalTurns += 1;
+                }
                 if (t.usageReported) {
                     if (addUsageInto(agg.usage, t.usage))
                         agg.usageReported = true;
@@ -657,6 +693,9 @@ export class TelemetryRecorder {
                 usageReported: false,
                 retryCount: 0,
             };
+            const goalSnap = cleanGoalSnapshot(meta.goal);
+            if (goalSnap)
+                turn.goal = goalSnap;
             this.session.turns.push(turn);
             this.openTurns.set(id, turn);
             this.pendingRetries = [];