@granular-software/sdk 0.4.24 → 0.4.26

package/dist/index.js

@@ -4567,6 +4567,7 @@ var Session = class {
   client;
   clientId;
   jobsMap = /* @__PURE__ */ new Map();
+  pendingAgentMessagesByJobId = /* @__PURE__ */ new Map();
   eventListeners = /* @__PURE__ */ new Map();
   toolHandlers = /* @__PURE__ */ new Map();
   /** Tracks which tools are instance methods (className set, not static) */
@@ -4609,6 +4610,22 @@ var Session = class {
       }
     };
   }
+  stringifyConversationValue(value) {
+    if (typeof value === "string") {
+      return value;
+    }
+    if (typeof value === "boolean") {
+      return value ? "Confirmed" : "Canceled";
+    }
+    if (value === void 0) {
+      return "";
+    }
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return String(value);
+    }
+  }
   // --- Public API ---
   get document() {
     return this.client.doc;
@@ -4724,6 +4741,15 @@ var Session = class {
       createdAt: Date.now()
     });
     this.jobsMap.set(result.jobId, job);
+    const pendingAgentMessages = this.pendingAgentMessagesByJobId.get(
+      result.jobId
+    );
+    if (pendingAgentMessages && pendingAgentMessages.length > 0) {
+      this.pendingAgentMessagesByJobId.delete(result.jobId);
+      for (const message of pendingAgentMessages) {
+        job.replayAgentMessage(message);
+      }
+    }
     return job;
   }
   /**
@@ -4750,6 +4776,20 @@ var Session = class {
       answer: resolvedAnswer,
       value: resolvedAnswer
     });
+    try {
+      const content = this.stringifyConversationValue(resolvedAnswer);
+      if (content.trim()) {
+        await this.appendConversationMessage({
+          role: "user",
+          content,
+          promptId
+        });
+      }
+    } catch {
+    }
+  }
+  async appendConversationMessage(input) {
+    return this.client.call("conversation.append", input);
   }
   /**
    * Get the current list of available effects.
@@ -5125,6 +5165,22 @@ import { ${allImports} } from "./sandbox-tools";
     this.client.on("job.status", (data) => {
       this.emit("job:status", data);
     });
+    this.client.on("job.agent_message", (data) => {
+      const normalized = normalizeJobAgentMessageEnvelope(data);
+      if (!normalized) return;
+      if (this.jobsMap.has(normalized.jobId)) return;
+      const pending = this.pendingAgentMessagesByJobId.get(normalized.jobId) || [];
+      if (normalized.message.messageId && pending.some(
+        (message) => message.messageId === normalized.message.messageId
+      )) {
+        return;
+      }
+      pending.push(normalized.message);
+      this.pendingAgentMessagesByJobId.set(
+        normalized.jobId,
+        pending.slice(-25)
+      );
+    });
     this.client.on("exec.completed", (data) => {
       this.emit("exec:completed", data);
     });
@@ -5249,6 +5305,22 @@ function sanitizeFeedbackValue(value, depth = 0, seen = /* @__PURE__ */ new Weak
   }
   return truncateFeedbackString(String(value));
 }
+function normalizeJobAgentMessageEnvelope(data) {
+  const d = data;
+  if (typeof d?.jobId !== "string" || !d.jobId) {
+    return null;
+  }
+  return {
+    jobId: d.jobId,
+    message: {
+      messageId: d.messageId,
+      kind: d.kind === "artifacts" ? "artifacts" : "text",
+      reply: typeof d.reply === "string" ? d.reply : "",
+      show: d.show,
+      timestamp: d.timestamp || Date.now()
+    }
+  };
+}
 var JobImplementation = class {
   id;
   client;
@@ -5257,6 +5329,8 @@ var JobImplementation = class {
   _resolveResult;
   _rejectResult;
   eventListeners = /* @__PURE__ */ new Map();
+  bufferedAgentMessages = [];
+  bufferedAgentMessageIds = /* @__PURE__ */ new Set();
   metadata;
   constructor(id, client, initialState) {
     this.id = id;
@@ -5415,14 +5489,9 @@ var JobImplementation = class {
       }
     });
     this.client.on("job.agent_message", (data) => {
-      const d = data;
-      if (d.jobId === id) {
-        this.emit("agentMessage", {
-          messageId: d.messageId,
-          reply: typeof d.reply === "string" ? d.reply : "",
-          show: d.show,
-          timestamp: d.timestamp || Date.now()
-        });
+      const normalized = normalizeJobAgentMessageEnvelope(data);
+      if (normalized?.jobId === id) {
+        this.captureAgentMessage(normalized.message);
       }
     });
   }
@@ -5449,6 +5518,14 @@ var JobImplementation = class {
       this.eventListeners.set(event, []);
     }
     this.eventListeners.get(event).push(handler);
+    if (event === "agentMessage" && this.bufferedAgentMessages.length > 0) {
+      for (const message of this.bufferedAgentMessages) {
+        handler(message);
+      }
+    }
+  }
+  replayAgentMessage(message) {
+    this.captureAgentMessage(message);
   }
   buildFeedbackMetadata() {
     const startedAt = this.metadata.startedAt;
@@ -5518,6 +5595,18 @@ var JobImplementation = class {
       handlers.forEach((h) => h(data));
     }
   }
+  captureAgentMessage(message) {
+    if (message.messageId && this.bufferedAgentMessageIds.has(message.messageId)) {
+      return;
+    }
+    if (message.messageId) {
+      this.bufferedAgentMessageIds.add(message.messageId);
+    }
+    this.bufferedAgentMessages = [...this.bufferedAgentMessages, message].slice(
+      -25
+    );
+    this.emit("agentMessage", message);
+  }
 };
 
 // src/endpoints.ts
@@ -13572,14 +13661,22 @@ function reviewGeneratedJobCode(code) {
       }
     }
   }
-  const hasConversationalReturn = /return\s+[`'"]/.test(normalized) || /\breply\s*:/.test(normalized) || /\bagent_message\s*\(/.test(normalized);
+  const hasConversationalReturn = /return\s+[`'"]/.test(normalized) || /\breply\s*:/.test(normalized) || /\bagent_message\s*\(/.test(normalized) || /\bagent_text_message\s*\(/.test(normalized);
   const returnsObjectLiteral = /return\s+\{[\s\S]*?\}/.test(normalized);
+  const returnsShowPayload = /return\s+\{[\s\S]*?\bshow\s*:/.test(normalized);
   const closesLoop = /loop\.close_loop\s*\(/.test(normalized);
   if (!hasConversationalReturn && returnsObjectLiteral && !closesLoop) {
     issues.push({
       code: "missing_user_reply",
       severity: "error",
-      message: "User-facing jobs must end with a natural-language answer. Return a short string, an object with a top-level `reply` string, or use agent_message({ reply, show }). Do not end with bare structured JSON."
+      message: "User-facing jobs must end with a natural-language answer. Return a short string, an object with a top-level `reply` string, or post text with agent_text_message(...). Do not end with bare structured JSON."
+    });
+  }
+  if (returnsShowPayload) {
+    issues.push({
+      code: "return_show_not_for_ui",
+      severity: "error",
+      message: "Do not use the final return value to send UI record refs through `show`. Use agent_heap_objects(...) for heap-backed UI, then return plain text if you still want a final textual answer."
     });
   }
   return issues;
@@ -14429,7 +14526,7 @@ ${loopBlock}
 
 \u2500\u2500\u2500 CODE RULES \u2500\u2500\u2500
 - Import from \`./sandbox-tools\`.
-- If you use \`heap\`, \`loop\`, or \`agent_message\`, import them explicitly from \`./sandbox-tools\`.
+- If you use \`heap\`, \`loop\`, \`agent_text_message\`, \`agent_heap_objects\`, or legacy \`agent_message\`, import them explicitly from \`./sandbox-tools\`.
 - Write top-level executable code with \`await\` at top level.
 - The generated job body must be plain runnable JavaScript. The DOMAIN TYPES block is only a reference for shapes and available methods.
 - Do not write TypeScript-only syntax in executable code: no type annotations, no interfaces, no enums, no \`as Type\` casts, no \`satisfies\`, and no generic type parameters in code.
@@ -14471,21 +14568,31 @@ ${loopBlock}
   - \`loop.close_loop(...)\`: record the current workflow outcome with a short summary before stopping. Do not call it in the same job that opens a new user prompt unless the workflow is explicitly blocked. This does not end the session forever.
 - Avoid \`as any\` and other broad casts when the DOMAIN TYPES block already tells you the correct class or list type.
 - Prefer manipulating heap-backed instances and typed lists instead of returning raw JSON blobs or object IDs unless the user explicitly asks for them.
-- If the user expects an answer after the job runs, the final \`return\` value must be either a short natural-language string or an object with a top-level \`reply\` string.
-- You may call \`agent_message(...)\` multiple times in one job to post several assistant messages while the job is still running.
-- Prefer \`agent_message({ reply, show })\` when you want to leave a user-facing answer and optionally show heap-backed records in the UI.
-- \`agent_message(...)\` also accepts \`content\`, \`message\`, or \`text\` instead of \`reply\`.
-- \`agent_message({ show })\` may receive explicit refs or sandbox instances and arrays of sandbox instances. The runtime will convert those into UI references.
-- When it helps the UI show specific heap-backed results, you may instead return:
-  \`{ reply: string, show: { entryPaths?: string[], listNames?: string[], variableNames?: string[] } }\`
-- If you create or load objects the user should see, save them in the heap and return references to them through \`show\` instead of serializing full objects.
+- Every job that intends to answer the user must emit at least one explicit UI message with \`agent_text_message(...)\` and/or \`agent_heap_objects(...)\`.
+- Use \`agent_text_message("...")\` for all user-visible text shown in the UI.
+- Use \`agent_heap_objects(...)\` only when you want the UI to render heap-backed records or lists.
+- If you want to show both text and records, call \`agent_text_message(...)\` and \`agent_heap_objects(...)\` separately in whatever order fits the interaction.
+- \`agent_text_message(...)\` should be used with a plain text string in normal generated code.
+- \`agent_heap_objects(...)\` should point at heap-backed values: explicit \`entryPaths\` / \`listNames\` / \`variableNames\`, a named list saved with \`saveAs\`, or values read back from \`heap.getVar(...)\`.
+- If you just fetched records and want to show them in the UI, save or reference them through the heap first, then call \`agent_heap_objects(...)\`. Do not try to hand-build UI payloads in job code.
+- Do not assume heap changes will be displayed automatically. If records should appear in the UI, you must call \`agent_heap_objects(...)\`.
+- Never write \`return { reply, show }\` or \`return { show: ... }\` for UI. If you want the UI to render records or lists, call \`agent_heap_objects(...)\` instead.
+- Do not rely on the final return value for user-visible output. A plain return value is not considered a displayed UI answer.
+- \`agent_message(...)\` remains available as a legacy compatibility alias, but prefer \`agent_text_message(...)\` and \`agent_heap_objects(...)\` in new code.
 - Do not return bare structured JSON, low-level diagnostics, or database-shaped payloads as the final answer unless the user explicitly asks for them.
 - Prefer simple executable JavaScript over clever interpolation. Avoid nested template literals or unusually dense inline expressions when a small temporary variable or string concatenation would be clearer and safer.
 - Use \`console.log()\` only for intermediate diagnostics, not for the final user-facing answer.`;
 }
 
 // src/job-presentation.ts
-var RESPONSE_KEYS = ["reply", "response", "text", "message", "summary", "answer"];
+var RESPONSE_KEYS = [
+  "reply",
+  "response",
+  "text",
+  "message",
+  "summary",
+  "answer"
+];
 var ENTRY_KEY_CANDIDATES = ["entryPath", "path"];
 var ENTRY_ARRAY_KEY_CANDIDATES = ["entryPaths", "paths"];
 var LIST_KEY_CANDIDATES = ["listName"];
@@ -14527,15 +14634,22 @@ function pushStringArray(target, value) {
   }
 }
 function collectReferencesFromRecord(record, refs) {
-  for (const key of ENTRY_KEY_CANDIDATES) pushString(refs.entryPaths, record[key]);
-  for (const key of ENTRY_ARRAY_KEY_CANDIDATES) pushStringArray(refs.entryPaths, record[key]);
-  for (const key of LIST_KEY_CANDIDATES) pushString(refs.listNames, record[key]);
-  for (const key of LIST_ARRAY_KEY_CANDIDATES) pushStringArray(refs.listNames, record[key]);
-  for (const key of VARIABLE_KEY_CANDIDATES) pushString(refs.variableNames, record[key]);
-  for (const key of VARIABLE_ARRAY_KEY_CANDIDATES) pushStringArray(refs.variableNames, record[key]);
+  for (const key of ENTRY_KEY_CANDIDATES)
+    pushString(refs.entryPaths, record[key]);
+  for (const key of ENTRY_ARRAY_KEY_CANDIDATES)
+    pushStringArray(refs.entryPaths, record[key]);
+  for (const key of LIST_KEY_CANDIDATES)
+    pushString(refs.listNames, record[key]);
+  for (const key of LIST_ARRAY_KEY_CANDIDATES)
+    pushStringArray(refs.listNames, record[key]);
+  for (const key of VARIABLE_KEY_CANDIDATES)
+    pushString(refs.variableNames, record[key]);
+  for (const key of VARIABLE_ARRAY_KEY_CANDIDATES)
+    pushStringArray(refs.variableNames, record[key]);
 }
 function scanForHeapReferences(value, heap, refs, depth = 0, seen = /* @__PURE__ */ new Set()) {
-  if (value === null || value === void 0 || depth > 4 || seen.has(value)) return;
+  if (value === null || value === void 0 || depth > 4 || seen.has(value))
+    return;
   if (typeof value === "string") {
     const trimmed = value.trim();
     if (heap.entriesByPath?.[trimmed]) refs.entryPaths.add(trimmed);
@@ -14631,12 +14745,16 @@ function fallbackResponseText(entries, lists) {
 }
 function getJobRelatedEntries(heap, jobId) {
   return sortEntries(
-    Object.values(heap.entriesByPath || {}).filter((entry) => entry.relatedJobIds?.includes(jobId))
+    Object.values(heap.entriesByPath || {}).filter(
+      (entry) => entry.relatedJobIds?.includes(jobId)
+    )
   );
 }
 function getJobRelatedLists(heap, jobId) {
   return sortLists(
-    Object.values(heap.listsByName || {}).filter((list) => list.relatedJobIds?.includes(jobId))
+    Object.values(heap.listsByName || {}).filter(
+      (list) => list.relatedJobIds?.includes(jobId)
+    )
   );
 }
 function entriesFromLists(lists, heap) {
@@ -14653,15 +14771,18 @@ function resolveJobPresentation({
   jobId,
   result,
   stdout = [],
-  sessionHeap
+  sessionHeap,
+  allowExplicitArtifacts = true
 }) {
   const refs = {
     entryPaths: /* @__PURE__ */ new Set(),
     listNames: /* @__PURE__ */ new Set(),
     variableNames: /* @__PURE__ */ new Set()
   };
-  scanForHeapReferences(result, sessionHeap, refs);
-  resolveVariablesToReferences(refs.variableNames, sessionHeap, refs);
+  if (allowExplicitArtifacts) {
+    scanForHeapReferences(result, sessionHeap, refs);
+    resolveVariablesToReferences(refs.variableNames, sessionHeap, refs);
+  }
   const referencedLists = sortLists(
     [...refs.listNames].map((name) => sessionHeap.listsByName?.[name]).filter((list) => Boolean(list))
   );
@@ -14674,22 +14795,324 @@ function resolveJobPresentation({
     ...jobEntries,
     ...entriesFromLists(jobLists, sessionHeap)
   ]);
-  const lists = dedupeLists([...referencedLists, ...jobLists]);
-  const entries = dedupeEntries([
+  const explicitLists = dedupeLists(referencedLists);
+  const explicitEntries = dedupeEntries([
     ...referencedEntries,
-    ...entriesFromLists(referencedLists, sessionHeap),
-    ...jobEntries,
-    ...entriesFromLists(jobLists, sessionHeap)
+    ...entriesFromLists(referencedLists, sessionHeap)
   ]);
+  const hasExplicitArtifacts = allowExplicitArtifacts && (explicitEntries.length > 0 || explicitLists.length > 0);
+  const lists = hasExplicitArtifacts ? explicitLists : jobLists;
+  const entries = hasExplicitArtifacts ? explicitEntries : changedEntries;
   const responseText = extractResponseText(result, stdout) || fallbackResponseText(entries, lists);
   return {
     responseText,
     entries,
     lists,
     changedEntries,
-    changedLists: jobLists
+    changedLists: jobLists,
+    hasExplicitArtifacts
+  };
+}
+
+// src/session-transcript.ts
+var EMPTY_HEAP = {
+  entriesByPath: {},
+  listsByName: {},
+  variablesByName: {}};
+function asRecord4(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
+}
+function asArray2(value) {
+  return Array.isArray(value) ? value : [];
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function trimString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function normalizeShowRefs(value) {
+  const record = asRecord4(value);
+  if (!record) return void 0;
+  const normalizeRefs = (input) => {
+    if (!Array.isArray(input)) return void 0;
+    const refs = Array.from(
+      new Set(
+        input.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean)
+      )
+    );
+    return refs.length > 0 ? refs : void 0;
+  };
+  const show = {
+    entryPaths: normalizeRefs(record.entryPaths),
+    listNames: normalizeRefs(record.listNames),
+    variableNames: normalizeRefs(record.variableNames)
+  };
+  return show.entryPaths || show.listNames || show.variableNames ? show : void 0;
+}
+function stringifyTranscriptValue(value, fallback = "") {
+  if (typeof value === "string") {
+    return value.trim() || fallback;
+  }
+  if (typeof value === "boolean") {
+    return value ? "Confirmed" : "Canceled";
+  }
+  if (value === void 0) {
+    return fallback;
+  }
+  try {
+    const json = JSON.stringify(value, null, 2);
+    if (!json || json === "undefined") return fallback;
+    return json.length > 2e3 ? `${json.slice(0, 2e3)}...` : json;
+  } catch {
+    return String(value);
+  }
+}
+function buildArtifactHistory(show) {
+  if (!show) return void 0;
+  return `[Agent message]
+${stringifyTranscriptValue({ show }, "")}`;
+}
+function normalizeConversationMessage(raw) {
+  const record = asRecord4(raw);
+  if (!record) return null;
+  const role = record.role === "user" ? "user" : record.role === "assistant" ? "assistant" : null;
+  if (!role) return null;
+  const content = trimString(
+    record.content ?? record.reply ?? record.message ?? record.text
+  );
+  const show = normalizeShowRefs(record.show);
+  const id = asString(record.id) || crypto.randomUUID();
+  const timestamp = asNumber(record.timestamp) || asNumber(record.ts) || 0;
+  if (!content && !show) return null;
+  return {
+    id,
+    role,
+    content,
+    timestamp,
+    jobId: asString(record.jobId),
+    promptId: asString(record.promptId),
+    show,
+    historyContent: role === "assistant" ? content ? `[Assistant reply]
+${content}` : buildArtifactHistory(show) : void 0,
+    source: "conversation"
   };
 }
+function normalizePromptEntries(jobId, rawPrompts, conversationPromptIds) {
+  const promptsById = asRecord4(rawPrompts) || {};
+  return Object.values(promptsById).map((value) => asRecord4(value)).filter((value) => Boolean(value)).sort(
+    (left, right) => (asNumber(left.openedAt) || asNumber(left.answeredAt) || 0) - (asNumber(right.openedAt) || asNumber(right.answeredAt) || 0)
+  ).flatMap((prompt) => {
+    const promptId = asString(prompt.promptId);
+    if (!promptId || conversationPromptIds.has(promptId)) return [];
+    const title = trimString(prompt.title);
+    const message = trimString(prompt.message);
+    const assistantContent = message || title || "Input required";
+    const openedAt = asNumber(prompt.openedAt) || 0;
+    const answeredAt = asNumber(prompt.answeredAt) || openedAt;
+    const entries = [
+      {
+        id: `prompt:${promptId}:assistant`,
+        role: "assistant",
+        content: assistantContent,
+        timestamp: openedAt,
+        jobId,
+        promptId,
+        historyContent: `[Assistant reply]
+${assistantContent}`,
+        source: "job_prompt"
+      }
+    ];
+    if (Object.prototype.hasOwnProperty.call(prompt, "answer")) {
+      entries.push({
+        id: `prompt:${promptId}:user`,
+        role: "user",
+        content: stringifyTranscriptValue(prompt.answer, ""),
+        timestamp: answeredAt,
+        jobId,
+        promptId,
+        source: "job_prompt"
+      });
+    }
+    return entries;
+  });
+}
+function normalizeAgentMessageEntries(jobId, rawMessages) {
+  return asArray2(rawMessages).map((value) => asRecord4(value)).filter((value) => Boolean(value)).sort(
+    (left, right) => (asNumber(left.timestamp) || asNumber(left.ts) || 0) - (asNumber(right.timestamp) || asNumber(right.ts) || 0)
+  ).flatMap((message) => {
+    const messageId = asString(message.messageId) || asString(message.id) || crypto.randomUUID();
+    const timestamp = asNumber(message.timestamp) || asNumber(message.ts) || 0;
+    const reply = trimString(
+      message.reply ?? message.message ?? message.text ?? message.content
+    );
+    const show = normalizeShowRefs(message.show);
+    const entries = [];
+    if (reply) {
+      entries.push({
+        id: `agent:${messageId}:text`,
+        role: "assistant",
+        content: reply,
+        timestamp,
+        jobId,
+        historyContent: `[Assistant reply]
+${reply}`,
+        source: "job_agent_message"
+      });
+    }
+    if (show) {
+      entries.push({
+        id: `agent:${messageId}:artifacts`,
+        role: "assistant",
+        content: "",
+        timestamp,
+        jobId,
+        show,
+        historyContent: buildArtifactHistory(show),
+        source: "job_agent_message"
+      });
+    }
+    return entries;
+  });
+}
+function buildJobFallbackEntries(jobId, job, sessionHeap) {
+  const timestamp = asNumber(job.finishedAt) || asNumber(job.startedAt) || asNumber(job.submittedAt) || 0;
+  const resultPreview = stringifyTranscriptValue(
+    job.result,
+    "No job result recorded."
+  );
+  const presentation = resolveJobPresentation({
+    jobId,
+    result: job.result,
+    stdout: [],
+    sessionHeap
+  });
+  const entries = [];
+  const responseText = presentation.responseText || "";
+  if (responseText) {
+    entries.push({
+      id: `job:${jobId}:result-text`,
+      role: "assistant",
+      content: responseText,
+      timestamp,
+      jobId,
+      historyContent: `[Assistant reply]
+${responseText}`,
+      source: "job_result"
+    });
+  }
+  const show = {
+    entryPaths: presentation.entries.map((entry) => entry.path),
+    listNames: presentation.lists.map((list) => list.name)
+  };
+  if (show.entryPaths && show.entryPaths.length > 0 || show.listNames && show.listNames.length > 0) {
+    entries.push({
+      id: `job:${jobId}:result-artifacts`,
+      role: "assistant",
+      content: "",
+      timestamp,
+      jobId,
+      show,
+      historyContent: buildArtifactHistory(show),
+      source: "job_result"
+    });
+  }
+  if (entries.length === 0 && trimString(job.error)) {
+    entries.push({
+      id: `job:${jobId}:result-error`,
+      role: "assistant",
+      content: trimString(job.error),
+      timestamp,
+      jobId,
+      historyContent: `[Assistant reply]
+${trimString(job.error)}`,
+      source: "job_result"
+    });
+  }
+  if (entries.length === 0 && resultPreview && resultPreview !== "No job result recorded.") {
+    entries.push({
+      id: `job:${jobId}:result-preview`,
+      role: "assistant",
+      content: resultPreview,
+      timestamp,
+      jobId,
+      historyContent: `[Assistant reply]
+${resultPreview}`,
+      source: "job_result"
+    });
+  }
+  return entries;
+}
+function buildJobCodeEntry(jobId, job) {
+  const code = trimString(job.source);
+  if (!code) return null;
+  const jobStatus = asString(job.status);
+  const error = jobStatus === "failed" || jobStatus === "canceled" || jobStatus === "timeout" ? trimString(job.error) || `Job ${jobStatus}` : void 0;
+  return {
+    id: `job:${jobId}:code`,
+    role: "assistant",
+    content: "",
+    timestamp: asNumber(job.submittedAt) || asNumber(job.startedAt) || asNumber(job.finishedAt) || 0,
+    jobId,
+    code,
+    jobStatus,
+    jobResultPreview: stringifyTranscriptValue(job.result, "No job result recorded."),
+    error,
+    source: "job_code"
+  };
+}
+function buildSessionTranscript(input) {
+  const liveDoc = input.liveDoc || null;
+  const sessionHeap = input.sessionHeap || EMPTY_HEAP;
+  const transcript = [];
+  const conversationMessages = asArray2(asRecord4(liveDoc?.conversation)?.messages).map((message) => normalizeConversationMessage(message)).filter((message) => Boolean(message));
+  const conversationPromptIds = new Set(
+    conversationMessages.map((message) => message.promptId).filter((promptId) => Boolean(promptId))
+  );
+  const assistantConversationJobIds = new Set(
+    conversationMessages.filter((message) => message.role === "assistant" && Boolean(message.jobId)).map((message) => message.jobId)
+  );
+  transcript.push(...conversationMessages);
+  const jobsById = asRecord4(asRecord4(liveDoc?.jobs)?.byId) || {};
+  const jobs = Object.values(jobsById).map((value) => asRecord4(value)).filter((value) => Boolean(value)).sort(
+    (left, right) => (asNumber(left.submittedAt) || asNumber(left.startedAt) || asNumber(left.finishedAt) || 0) - (asNumber(right.submittedAt) || asNumber(right.startedAt) || asNumber(right.finishedAt) || 0)
+  );
+  for (const job of jobs) {
+    const jobId = asString(job.jobId);
+    if (!jobId) continue;
+    const codeEntry = buildJobCodeEntry(jobId, job);
+    if (codeEntry) {
+      transcript.push(codeEntry);
+    }
+    transcript.push(
+      ...normalizePromptEntries(jobId, job.prompts, conversationPromptIds)
+    );
+    if (!assistantConversationJobIds.has(jobId)) {
+      const agentEntries = normalizeAgentMessageEntries(jobId, job.agentMessages);
+      if (agentEntries.length > 0) {
+        transcript.push(...agentEntries);
+      } else {
+        transcript.push(
+          ...buildJobFallbackEntries(
+            jobId,
+            job,
+            sessionHeap
+          )
+        );
+      }
+    }
+  }
+  return transcript.sort((left, right) => {
+    if (left.timestamp !== right.timestamp) {
+      return left.timestamp - right.timestamp;
+    }
+    return left.id.localeCompare(right.id);
+  });
+}
 
 exports.Environment = Environment;
 exports.Granular = Granular;
@@ -14704,6 +15127,7 @@ exports.buildGranularAgentSessionBlock = buildGranularAgentSessionBlock;
 exports.buildGranularAgentSystemPrompt = buildGranularAgentSystemPrompt;
 exports.buildGranularAgentToolBlock = buildGranularAgentToolBlock;
 exports.buildGranularAgentWorkflowBlock = buildGranularAgentWorkflowBlock;
+exports.buildSessionTranscript = buildSessionTranscript;
 exports.createHarnessVerifierSnapshot = createHarnessVerifierSnapshot;
 exports.evaluateContinuation = evaluateContinuation;
 exports.extractPromptTokens = extractPromptTokens;