@granular-software/sdk 0.4.32 → 0.4.34

package/dist/agent-evals.mjs

@@ -5619,6 +5619,540 @@ var JobImplementation = class {
   }
 };
 
+// src/job-presentation.ts
+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"];
+var LIST_ARRAY_KEY_CANDIDATES = ["listNames"];
+var VARIABLE_KEY_CANDIDATES = ["variableName"];
+var VARIABLE_ARRAY_KEY_CANDIDATES = ["variableNames"];
+var UI_CONTAINER_KEYS = ["show", "display", "present", "ui"];
+function asRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
+}
+function normalizeText(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    return null;
+  }
+  return trimmed;
+}
+function humanTextFromStdout(stdout) {
+  for (const line of [...stdout].reverse()) {
+    const normalized = normalizeText(line);
+    if (!normalized) continue;
+    if (/^[A-Z_]+:/.test(normalized)) continue;
+    return normalized;
+  }
+  return null;
+}
+function pushString(target, value) {
+  if (typeof value === "string" && value.trim()) {
+    target.add(value.trim());
+  }
+}
+function pushStringArray(target, value) {
+  if (!Array.isArray(value)) return;
+  for (const item of value) {
+    pushString(target, item);
+  }
+}
+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]);
+}
+function scanForHeapReferences(value, heap, refs, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  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);
+    if (heap.listsByName?.[trimmed]) refs.listNames.add(trimmed);
+    if (heap.variablesByName?.[trimmed]) refs.variableNames.add(trimmed);
+    return;
+  }
+  if (Array.isArray(value)) {
+    seen.add(value);
+    for (const item of value.slice(0, 24)) {
+      scanForHeapReferences(item, heap, refs, depth + 1, seen);
+    }
+    return;
+  }
+  const record = asRecord2(value);
+  if (!record) return;
+  seen.add(value);
+  collectReferencesFromRecord(record, refs);
+  for (const key of UI_CONTAINER_KEYS) {
+    const nested = asRecord2(record[key]);
+    if (nested) collectReferencesFromRecord(nested, refs);
+  }
+  for (const nested of Object.values(record).slice(0, 24)) {
+    scanForHeapReferences(nested, heap, refs, depth + 1, seen);
+  }
+}
+function resolveVariablesToReferences(variableNames, heap, refs) {
+  for (const variableName of variableNames) {
+    const variable = heap.variablesByName?.[variableName];
+    if (!variable) continue;
+    if (variable.kind === "entry" && variable.entryPath) {
+      refs.entryPaths.add(variable.entryPath);
+    }
+    if (variable.kind === "list" && variable.listName) {
+      refs.listNames.add(variable.listName);
+    }
+  }
+}
+function sortEntries(entries) {
+  return [...entries].sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+}
+function sortLists(lists) {
+  return [...lists].sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+}
+function dedupeEntries(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const entry of entries) {
+    if (!entry?.path || seen.has(entry.path)) continue;
+    seen.add(entry.path);
+    result.push(entry);
+  }
+  return result;
+}
+function dedupeLists(lists) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const list of lists) {
+    if (!list?.name || seen.has(list.name)) continue;
+    seen.add(list.name);
+    result.push(list);
+  }
+  return result;
+}
+function extractResponseText(result, stdout) {
+  const directText = normalizeText(result);
+  if (directText) return directText;
+  const record = asRecord2(result);
+  if (record) {
+    for (const key of RESPONSE_KEYS) {
+      const normalized = normalizeText(record[key]);
+      if (normalized) return normalized;
+    }
+    for (const containerKey of UI_CONTAINER_KEYS) {
+      const nested = asRecord2(record[containerKey]);
+      if (!nested) continue;
+      for (const key of RESPONSE_KEYS) {
+        const normalized = normalizeText(nested[key]);
+        if (normalized) return normalized;
+      }
+    }
+  }
+  return humanTextFromStdout(stdout);
+}
+function fallbackResponseText(entries, lists) {
+  if (entries.length > 0) {
+    return entries.length === 1 ? "I found one relevant record." : `I found ${entries.length} relevant records.`;
+  }
+  if (lists.length > 0) {
+    const emptyOnly = lists.every((list) => (list.paths || []).length === 0);
+    if (emptyOnly) {
+      return lists.length === 1 ? "I saved one empty result set." : `I saved ${lists.length} empty result sets.`;
+    }
+    return lists.length === 1 ? "I saved one result set." : `I saved ${lists.length} result sets.`;
+  }
+  return null;
+}
+function getJobRelatedEntries(heap, jobId) {
+  return sortEntries(
+    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)
+    )
+  );
+}
+function entriesFromLists(lists, heap) {
+  const entries = [];
+  for (const list of lists) {
+    for (const path2 of list.paths || []) {
+      const entry = heap.entriesByPath?.[path2];
+      if (entry) entries.push(entry);
+    }
+  }
+  return entries;
+}
+function resolveJobPresentation({
+  jobId,
+  result,
+  stdout = [],
+  sessionHeap,
+  allowExplicitArtifacts = true
+}) {
+  const refs = {
+    entryPaths: /* @__PURE__ */ new Set(),
+    listNames: /* @__PURE__ */ new Set(),
+    variableNames: /* @__PURE__ */ new Set()
+  };
+  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))
+  );
+  const referencedEntries = sortEntries(
+    [...refs.entryPaths].map((path2) => sessionHeap.entriesByPath?.[path2]).filter((entry) => Boolean(entry))
+  );
+  const jobLists = getJobRelatedLists(sessionHeap, jobId);
+  const jobEntries = getJobRelatedEntries(sessionHeap, jobId);
+  const changedEntries = dedupeEntries([
+    ...jobEntries,
+    ...entriesFromLists(jobLists, sessionHeap)
+  ]);
+  const explicitLists = dedupeLists(referencedLists);
+  const explicitEntries = dedupeEntries([
+    ...referencedEntries,
+    ...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,
+    hasExplicitArtifacts
+  };
+}
+
+// src/session-transcript.ts
+var EMPTY_HEAP = {
+  entriesByPath: {},
+  listsByName: {},
+  variablesByName: {}};
+function asRecord3(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
+}
+function asArray(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 = asRecord3(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 = asRecord3(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 = asRecord3(rawPrompts) || {};
+  return Object.values(promptsById).map((value) => asRecord3(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 asArray(rawMessages).map((value) => asRecord3(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 = asArray(asRecord3(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 = asRecord3(asRecord3(liveDoc?.jobs)?.byId) || {};
+  const jobs = Object.values(jobsById).map((value) => asRecord3(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);
+  });
+}
+
 // src/endpoints.ts
 var LOCAL_API_URL = "ws://localhost:8787/granular";
 var PRODUCTION_API_URL = "wss://cf-api-gateway.arthur6084.workers.dev/granular";
@@ -10332,6 +10866,50 @@ function computeEffectKey(effect) {
   }
   return effect.static ? `class:${attachedClass}:static:${effect.name}` : `class:${attachedClass}:instance:${effect.name}`;
 }
+function computeEffectVersionSelectorSpecificity(selector) {
+  if (!selector || selector.mode === "all") {
+    return 0;
+  }
+  if (selector.mode === "exact") {
+    return 2;
+  }
+  return 1;
+}
+function matchesEffectVersionSelector(selector, buildVersionNumber) {
+  if (!selector || selector.mode === "all") {
+    return true;
+  }
+  if (typeof buildVersionNumber !== "number" || !Number.isFinite(buildVersionNumber)) {
+    return false;
+  }
+  if (selector.mode === "exact") {
+    return buildVersionNumber === selector.versionNumber;
+  }
+  if (selector.mode === "before") {
+    return buildVersionNumber < selector.versionNumber;
+  }
+  return buildVersionNumber > selector.versionNumber;
+}
+function selectRegisteredEffect(effectMap, effectKey, buildVersionNumber) {
+  let bestEffect;
+  let bestSpecificity = Number.NEGATIVE_INFINITY;
+  for (const effect of effectMap.values()) {
+    if (computeEffectKey(effect) !== effectKey) {
+      continue;
+    }
+    if (!matchesEffectVersionSelector(effect.versionSelector, buildVersionNumber)) {
+      continue;
+    }
+    const specificity = computeEffectVersionSelectorSpecificity(
+      effect.versionSelector
+    );
+    if (!bestEffect || specificity > bestSpecificity) {
+      bestEffect = effect;
+      bestSpecificity = specificity;
+    }
+  }
+  return bestEffect;
+}
 function normalizeEffectBehaviors(value) {
   return normalizeEffectBehaviorSummary(
     value
@@ -10352,9 +10930,17 @@ function resolveReverseEffect(effectMap, currentEffect, request, behaviors) {
     return void 0;
   }
   if (reverseHandler.includes(":")) {
-    return effectMap.get(reverseHandler);
+    return selectRegisteredEffect(
+      effectMap,
+      reverseHandler,
+      request.context?.buildVersionNumber
+    );
   }
-  const directMatch = effectMap.get(reverseHandler);
+  const directMatch = selectRegisteredEffect(
+    effectMap,
+    reverseHandler,
+    request.context?.buildVersionNumber
+  );
   if (directMatch) {
     return directMatch;
   }
@@ -10369,7 +10955,11 @@ function resolveReverseEffect(effectMap, currentEffect, request, behaviors) {
     })
   ];
   for (const candidateKey of candidateKeys) {
-    const candidate = effectMap.get(candidateKey);
+    const candidate = selectRegisteredEffect(
+      effectMap,
+      candidateKey,
+      request.context?.buildVersionNumber
+    );
     if (candidate) {
       return candidate;
     }
@@ -10405,7 +10995,11 @@ function resolveHandlerForMode(effectMap, effect, request) {
   return { effect, mode, handler: effect.handler };
 }
 async function invokeRegisteredEffect(effectMap, request) {
-  const effect = effectMap.get(request.effectKey);
+  const effect = selectRegisteredEffect(
+    effectMap,
+    request.effectKey,
+    request.context?.buildVersionNumber
+  );
   if (!effect) {
     throw new Error(`Effect handler not found: ${request.effectKey}`);
   }
@@ -11664,6 +12258,17 @@ function computeEffectKey2(effect) {
   }
   return effect.static ? `class:${attachedClass}:static:${effect.name}` : `class:${attachedClass}:instance:${effect.name}`;
 }
+function computeEffectVersionSelectorKey(selector) {
+  if (!selector || selector.mode === "all") {
+    return "all";
+  }
+  return `${selector.mode}:${selector.versionNumber}`;
+}
+function computeEffectRegistrationKey(effect) {
+  return `${computeEffectKey2(effect)}@${computeEffectVersionSelectorKey(
+    effect.versionSelector
+  )}`;
+}
 function buildEffectHostUrl(apiUrl, sandboxId, effectClientId, clientId) {
   const url = new URL(apiUrl);
   if (url.pathname.endsWith("/granular/ws/connect")) {
@@ -12158,7 +12763,9 @@ var Environment = class {
       { target: targetPath }
     );
     if (result.errors?.length) {
-      throw new Error(`attach failed: ${result.errors[0]?.message ?? "Unknown GraphQL error"}`);
+      throw new Error(
+        `attach failed: ${result.errors[0]?.message ?? "Unknown GraphQL error"}`
+      );
     }
   }
   /**
@@ -12193,7 +12800,9 @@ var Environment = class {
             }`
     );
     if (result.errors?.length) {
-      throw new Error(`detach failed: ${result.errors[0]?.message ?? "Unknown GraphQL error"}`);
+      throw new Error(
+        `detach failed: ${result.errors[0]?.message ?? "Unknown GraphQL error"}`
+      );
     }
   }
   /**
@@ -12315,7 +12924,9 @@ var Environment = class {
   async _runGraphql(query, label) {
     const result = await this.graphql(query);
     if (result.errors?.length) {
-      throw new Error(`${label}: ${result.errors[0]?.message ?? "Unknown GraphQL error"}`);
+      throw new Error(
+        `${label}: ${result.errors[0]?.message ?? "Unknown GraphQL error"}`
+      );
     }
     return result.data;
   }
@@ -12850,6 +13461,9 @@ var EnvironmentSession = class extends Session {
   get envName() {
     return this.environment.envName;
   }
+  get tag() {
+    return this.environment.tag;
+  }
   get versionId() {
     return this.environment.versionId;
   }
@@ -12869,12 +13483,171 @@ var EnvironmentSession = class extends Session {
     return this.environment.feedback;
   }
   /**
-   * Return a plain JS snapshot of the synced session heap.
+   * Return a plain JS copy of the synced session heap.
    */
   getHeap() {
     const doc = this.document;
     return normalizeHeapSnapshot(doc?.heap);
   }
+  async sessionDataRequest(path2, query) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(query || {})) {
+      if (value !== null && typeof value !== "undefined" && value !== "") {
+        searchParams.set(key, String(value));
+      }
+    }
+    const queryString = searchParams.toString();
+    const response = await fetch(
+      `${this.environment.runtimeBaseUrl}/orchestrator/ws/sessions/${encodeURIComponent(this.sessionId)}${path2}${queryString ? `?${queryString}` : ""}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.environment.authToken}`,
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Session data API Error (${response.status}): ${errorText}`
+      );
+    }
+    return response.json();
+  }
+  async collectAllSessionItems(listPage) {
+    const items = [];
+    let cursor = null;
+    do {
+      const page = await listPage({ limit: 500, cursor });
+      items.push(...page.items);
+      cursor = page.nextCursor;
+    } while (cursor);
+    return items;
+  }
+  /**
+   * Fetch the live session document from the runtime DO.
+   *
+   * For history and saved artifacts, prefer the collection APIs on
+   * `messages`, `timeline`, `jobs`, and `heap`.
+   */
+  async getDocument() {
+    return this.sessionDataRequest("/document");
+  }
+  get messages() {
+    return {
+      list: (options = {}) => this.sessionDataRequest(
+        "/messages",
+        options
+      )
+    };
+  }
+  get timeline() {
+    return {
+      list: (options = {}) => this.sessionDataRequest(
+        "/timeline",
+        options
+      )
+    };
+  }
+  get jobs() {
+    return {
+      list: (options = {}) => this.sessionDataRequest(
+        "/jobs",
+        options
+      ),
+      get: (jobId) => this.sessionDataRequest(
+        `/jobs/${encodeURIComponent(jobId)}`
+      )
+    };
+  }
+  get heap() {
+    return {
+      entries: {
+        list: (options = {}) => this.sessionDataRequest(
+          "/heap/entries",
+          options
+        ),
+        get: (path2) => this.sessionDataRequest(
+          `/heap/entries/${encodeURIComponent(path2)}`
+        )
+      },
+      lists: {
+        list: (options = {}) => this.sessionDataRequest(
+          "/heap/lists",
+          options
+        ),
+        get: (name) => this.sessionDataRequest(
+          `/heap/lists/${encodeURIComponent(name)}`
+        )
+      }
+    };
+  }
+  get transcript() {
+    return {
+      list: async (options = {}) => {
+        const [messages, jobs, entries, lists] = await Promise.all([
+          this.collectAllSessionItems(this.messages.list),
+          this.collectAllSessionItems(
+            (pageOptions) => this.jobs.list({ ...pageOptions, status: "all" })
+          ),
+          this.collectAllSessionItems(this.heap.entries.list),
+          this.collectAllSessionItems(this.heap.lists.list)
+        ]);
+        const liveDoc = {
+          conversation: { messages },
+          jobs: {
+            byId: Object.fromEntries(
+              jobs.map((job) => {
+                const record = job && typeof job === "object" ? job : null;
+                const id = typeof record?.jobId === "string" ? record.jobId : typeof record?.id === "string" ? record.id : null;
+                return id ? [id, record] : null;
+              }).filter(
+                (entry) => Boolean(entry)
+              )
+            )
+          }
+        };
+        const heap = normalizeHeapSnapshot({
+          entriesByPath: Object.fromEntries(
+            entries.map((entry) => {
+              return entry?.path ? [
+                entry.path,
+                entry
+              ] : null;
+            }).filter(
+              (entry) => Boolean(entry)
+            )
+          ),
+          listsByName: Object.fromEntries(
+            lists.map((list) => {
+              return list?.name ? [list.name, list] : null;
+            }).filter(
+              (entry) => Boolean(entry)
+            )
+          ),
+          variablesByName: this.getHeap().variablesByName,
+          updatedAt: Date.now()
+        });
+        const allItems = buildSessionTranscript({
+          liveDoc,
+          sessionHeap: heap
+        });
+        const limit = Math.max(
+          1,
+          Math.min(500, Math.floor(options.limit ?? 100))
+        );
+        const offset = typeof options.cursor === "string" ? Number.parseInt(options.cursor, 10) || 0 : 0;
+        const items = allItems.slice(offset, offset + limit);
+        const nextOffset = offset + items.length;
+        return {
+          items,
+          nextCursor: nextOffset < allItems.length ? String(nextOffset) : null,
+          totalCount: allItems.length
+        };
+      }
+    };
+  }
   async graphql(query, variables) {
     return this.environment.graphql(query, variables);
   }
@@ -13017,7 +13790,7 @@ var Granular = class _Granular {
   onUnexpectedClose;
   onReconnectError;
   debugHttp = process.env.GRANULAR_DEBUG_HTTP === "1";
-  /** Sandbox-level effect registry: sandboxId → (effectKey → ToolWithHandler) */
+  /** Sandbox-level effect registry: sandboxId → (effectKey@selector → ToolWithHandler) */
   sandboxEffects = /* @__PURE__ */ new Map();
   /** Live sandbox-scoped effect hosts keyed by sandboxId */
   sandboxEffectHosts = /* @__PURE__ */ new Map();
@@ -13436,7 +14209,8 @@ var Granular = class _Granular {
       provenance: effect.provenance || { source: "custom" },
       tags: effect.tags,
       className: effect.className,
-      static: effect.static
+      static: effect.static,
+      versionSelector: effect.versionSelector
     };
   }
   async publishSandboxEffectCatalog(host) {
@@ -13624,7 +14398,10 @@ var Granular = class _Granular {
   async registerEffect(sandboxNameOrId, effect) {
     const sandbox = await this.findOrCreateSandbox(sandboxNameOrId);
     const sandboxId = sandbox.sandboxId;
-    this.getSandboxEffectMap(sandboxId).set(computeEffectKey2(effect), effect);
+    this.getSandboxEffectMap(sandboxId).set(
+      computeEffectRegistrationKey(effect),
+      effect
+    );
     await this.syncSandboxEffectCatalog(sandboxId);
   }
   /**
@@ -13637,7 +14414,7 @@ var Granular = class _Granular {
     const sandboxId = sandbox.sandboxId;
     const map = this.getSandboxEffectMap(sandboxId);
     for (const effect of effects) {
-      map.set(computeEffectKey2(effect), effect);
+      map.set(computeEffectRegistrationKey(effect), effect);
     }
     await this.syncSandboxEffectCatalog(sandboxId);
   }
@@ -13655,7 +14432,7 @@ var Granular = class _Granular {
       return;
     }
     const nextEntries = Array.from(currentMap.entries()).filter(
-      ([effectKey, effect]) => effectKey !== name && effect.name !== name
+      ([, effect]) => computeEffectKey2(effect) !== name && effect.name !== name
     );
     if (nextEntries.length === currentMap.size) {
       return;
@@ -14084,15 +14861,15 @@ var Granular = class _Granular {
 };
 
 // src/agent-harness.ts
-function asRecord2(value) {
+function asRecord4(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   return value;
 }
-function asArray(value) {
+function asArray2(value) {
   return Array.isArray(value) ? value : [];
 }
 function toSortedRecords(value) {
-  return Object.values(asRecord2(value) || {}).map((entry) => asRecord2(entry)).filter((entry) => Boolean(entry));
+  return Object.values(asRecord4(value) || {}).map((entry) => asRecord4(entry)).filter((entry) => Boolean(entry));
 }
 function uniqueStrings(values, maxCount) {
   const seen = /* @__PURE__ */ new Set();
@@ -14118,7 +14895,7 @@ function describeHeapEntry(entry, previewFieldLimit = 3) {
   const headline = entry.label || entry.id || entry.path || "Unknown";
   const pathLabel = entry.path && entry.path !== headline ? ` <${entry.path}>` : "";
   const classLabel = entry.className || "unknown";
-  const preview = asArray(entry.fields).filter(
+  const preview = asArray2(entry.fields).filter(
     (field) => field?.name && field.name !== "_realId" && field.name !== "real_id"
   ).slice(0, previewFieldLimit).map((field) => `${field.name}=${formatScalar(field.value)}`).join(", ");
   return preview ? `${headline}${pathLabel} [${classLabel}] ${preview}` : `${headline}${pathLabel} [${classLabel}]`;
@@ -14255,14 +15032,14 @@ function normalizeActionSummaryForPrompt(line) {
   return line.replace(/\blimit=/g, "perPage=").replace(/\blimit:/g, "perPage:");
 }
 function getCurrentClosureId(liveDoc) {
-  const loop = asRecord2(liveDoc?.loop);
+  const loop = asRecord4(liveDoc?.loop);
   return typeof loop?.currentClosureId === "string" ? loop.currentClosureId : null;
 }
 function getLatestClosure(liveDoc) {
-  const loop = asRecord2(liveDoc?.loop);
+  const loop = asRecord4(liveDoc?.loop);
   const currentClosureId = getCurrentClosureId(liveDoc);
-  const closuresById = asRecord2(loop?.closuresById) || {};
-  const currentClosure = currentClosureId ? asRecord2(closuresById[currentClosureId]) : null;
+  const closuresById = asRecord4(loop?.closuresById) || {};
+  const currentClosure = currentClosureId ? asRecord4(closuresById[currentClosureId]) : null;
   if (currentClosure) {
     return {
       ...currentClosure,
@@ -14271,7 +15048,7 @@ function getLatestClosure(liveDoc) {
   }
   const closures = [];
   for (const [closureId, value] of Object.entries(closuresById)) {
-    const record = asRecord2(value);
+    const record = asRecord4(value);
     if (!record) continue;
     closures.push({ ...record, closureId });
   }
@@ -14308,10 +15085,10 @@ function getJobTimestamp(job) {
   return Number(job.finishedAt) || Number(job.startedAt) || Number(job.submittedAt) || 0;
 }
 function getJobRecords(liveDoc) {
-  const jobsById = asRecord2(asRecord2(liveDoc?.jobs)?.byId) || {};
+  const jobsById = asRecord4(asRecord4(liveDoc?.jobs)?.byId) || {};
   const jobs = [];
   for (const [jobId, value] of Object.entries(jobsById)) {
-    const record = asRecord2(value);
+    const record = asRecord4(value);
     if (!record) continue;
     jobs.push({ ...record, jobId });
   }
@@ -14321,7 +15098,7 @@ function getJobRecords(liveDoc) {
   return jobs;
 }
 function getPromptRecordsFromJobs(liveDoc) {
-  return getJobRecords(liveDoc).flatMap((job) => Object.values(asRecord2(job.prompts) || {})).map((prompt) => asRecord2(prompt)).filter((prompt) => Boolean(prompt));
+  return getJobRecords(liveDoc).flatMap((job) => Object.values(asRecord4(job.prompts) || {})).map((prompt) => asRecord4(prompt)).filter((prompt) => Boolean(prompt));
 }
 function projectWorkflowFocus(liveDoc, pendingPrompts = [], options) {
   const boundary = getWorkflowBoundary(liveDoc, options);
@@ -14336,15 +15113,15 @@ function projectWorkflowFocus(liveDoc, pendingPrompts = [], options) {
   const openDecisionIds = [];
   const openPromptIds = [];
   for (const job of jobs) {
-    for (const line of asArray(job.actionSummary)) {
+    for (const line of asArray2(job.actionSummary)) {
       if (typeof line === "string" && line.trim()) {
         actionSummaryLines.push(line.trim());
       }
     }
-    for (const rawEvent of asArray(job.actionTrace)) {
-      const event = asRecord2(rawEvent);
-      const details = asRecord2(event?.details);
-      const outcome = asRecord2(event?.outcome);
+    for (const rawEvent of asArray2(job.actionTrace)) {
+      const event = asRecord4(rawEvent);
+      const details = asRecord4(event?.details);
+      const outcome = asRecord4(event?.outcome);
       if (typeof details?.name === "string") {
         variableNames.push(details.name);
       }
@@ -14371,7 +15148,7 @@ function projectWorkflowFocus(liveDoc, pendingPrompts = [], options) {
       }
     }
   }
-  const loop = asRecord2(liveDoc?.loop);
+  const loop = asRecord4(liveDoc?.loop);
   const tasks = toSortedRecords(loop?.tasksById).filter((task) => {
     const updatedAt = Number(task.updatedAt) || Number(task.createdAt) || 0;
     const status = typeof task.status === "string" ? task.status : "pending";
@@ -14419,15 +15196,15 @@ function projectWorkflowFocus(liveDoc, pendingPrompts = [], options) {
       openPromptIds.push(prompt.id);
     }
   }
-  const heap = asRecord2(liveDoc?.heap);
-  const variablesByName = asRecord2(heap?.variablesByName) || {};
-  const listsByName = asRecord2(heap?.listsByName) || {};
+  const heap = asRecord4(liveDoc?.heap);
+  const variablesByName = asRecord4(heap?.variablesByName) || {};
+  const listsByName = asRecord4(heap?.listsByName) || {};
   const recentHints = extractFocusHintsFromActionSummary(actionSummaryLines);
   variableNames.push(...recentHints.variableNames);
   listNames.push(...recentHints.listNames);
   entryPaths.push(...recentHints.entryPaths);
   for (const variableName of uniqueStrings(variableNames)) {
-    const variable = asRecord2(variablesByName[variableName]);
+    const variable = asRecord4(variablesByName[variableName]);
     if (!variable) continue;
     if (typeof variable.listName === "string") {
       listNames.push(variable.listName);
@@ -14437,13 +15214,13 @@ function projectWorkflowFocus(liveDoc, pendingPrompts = [], options) {
     }
   }
   for (const listName of uniqueStrings(listNames)) {
-    const list = asRecord2(listsByName[listName]);
-    for (const path2 of asArray(list?.paths).slice(0, 4)) {
+    const list = asRecord4(listsByName[listName]);
+    for (const path2 of asArray2(list?.paths).slice(0, 4)) {
       entryPaths.push(path2);
     }
   }
   if (variableNames.length === 0 && boundary.reason !== "request_start") {
-    const recentVariables = Object.values(variablesByName).map((value) => asRecord2(value)).filter((value) => Boolean(value)).sort((left, right) => (right.updatedAt || 0) - (left.updatedAt || 0)).slice(0, 3);
+    const recentVariables = Object.values(variablesByName).map((value) => asRecord4(value)).filter((value) => Boolean(value)).sort((left, right) => (right.updatedAt || 0) - (left.updatedAt || 0)).slice(0, 3);
     for (const variable of recentVariables) {
       if (typeof variable.name === "string") {
         variableNames.push(variable.name);
@@ -14526,12 +15303,12 @@ function projectWorkflowSummary(liveDoc, pendingPrompts = [], options) {
 }
 function hasOpenPrompt(liveDoc, pendingPrompts) {
   if (pendingPrompts.length > 0) return true;
-  const jobsById = asRecord2(asRecord2(liveDoc?.jobs)?.byId) || {};
+  const jobsById = asRecord4(asRecord4(liveDoc?.jobs)?.byId) || {};
   for (const job of Object.values(jobsById)) {
-    const prompts = asRecord2(asRecord2(job)?.prompts);
+    const prompts = asRecord4(asRecord4(job)?.prompts);
     if (!prompts) continue;
     for (const prompt of Object.values(prompts)) {
-      const record = asRecord2(prompt);
+      const record = asRecord4(prompt);
       if (record?.status === "open") return true;
     }
   }
@@ -14539,7 +15316,7 @@ function hasOpenPrompt(liveDoc, pendingPrompts) {
 }
 function projectLoopSummary(liveDoc, pendingPrompts = [], options) {
   const lines = [];
-  const loop = asRecord2(liveDoc?.loop);
+  const loop = asRecord4(liveDoc?.loop);
   const boundary = getWorkflowBoundary(liveDoc, options);
   const tasks = toSortedRecords(loop?.tasksById).filter((task) => {
     const updatedAt = Number(task.updatedAt) || Number(task.createdAt) || 0;
@@ -14599,8 +15376,8 @@ function projectLoopSummary(liveDoc, pendingPrompts = [], options) {
       const title = typeof decision.title === "string" && decision.title.trim() ? decision.title.trim() : "Decision";
       const decisionId = typeof decision.decisionId === "string" ? decision.decisionId : "unknown";
       if (status === "open") {
-        const candidatePreview = asArray(decision.candidates).slice(0, 3).map((candidate) => {
-          const record = asRecord2(candidate);
+        const candidatePreview = asArray2(decision.candidates).slice(0, 3).map((candidate) => {
+          const record = asRecord4(candidate);
           if (!record) return null;
           const candidateId = typeof record.id === "string" ? record.id : "unknown";
           const candidateLabel = typeof record.label === "string" && record.label.trim() ? record.label.trim() : candidateId;
@@ -14610,7 +15387,7 @@ function projectLoopSummary(liveDoc, pendingPrompts = [], options) {
           `- [open] ${title} (${decisionId})${candidatePreview ? ` \u2014 candidates: ${candidatePreview}` : ""}`
         );
       } else {
-        const selected = asRecord2(decision.selected);
+        const selected = asRecord4(decision.selected);
         const label = typeof selected?.label === "string" ? selected.label : typeof selected?.id === "string" ? selected.id : "unknown";
         lines.push(`- [resolved] ${title} (${decisionId}) -> ${label}`);
       }
@@ -14623,12 +15400,12 @@ function projectLoopSummary(liveDoc, pendingPrompts = [], options) {
       title: prompt.title,
       message: prompt.message
     })),
-    ...Object.values(asRecord2(asRecord2(liveDoc?.jobs)?.byId) || {}).flatMap((job) => Object.values(asRecord2(asRecord2(job)?.prompts) || {})).map((prompt) => asRecord2(prompt)).filter(
+    ...Object.values(asRecord4(asRecord4(liveDoc?.jobs)?.byId) || {}).flatMap((job) => Object.values(asRecord4(asRecord4(job)?.prompts) || {})).map((prompt) => asRecord4(prompt)).filter(
       (prompt) => Boolean(prompt && prompt.status === "open")
     )
   ];
   const visiblePrompts = boundary.reason === "request_start" ? openPrompts.filter((prompt) => {
-    const promptRecord = asRecord2(prompt);
+    const promptRecord = asRecord4(prompt);
     const openedAt = Number(promptRecord?.openedAt) || 0;
     const promptId = typeof promptRecord?.id === "string" ? promptRecord.id : typeof prompt.id === "string" ? prompt.id : null;
     return openedAt >= boundary.timestamp || (promptId ? pendingPrompts.some(
@@ -14647,7 +15424,7 @@ function projectLoopSummary(liveDoc, pendingPrompts = [], options) {
     }
   }
   const currentClosureId = getCurrentClosureId(liveDoc);
-  const closureRecord = currentClosureId ? asRecord2(asRecord2(loop?.closuresById)?.[currentClosureId]) : null;
+  const closureRecord = currentClosureId ? asRecord4(asRecord4(loop?.closuresById)?.[currentClosureId]) : null;
   const visibleClosure = closureRecord && (boundary.reason !== "request_start" || (Number(closureRecord.createdAt) || 0) >= boundary.timestamp) ? closureRecord : null;
   lines.push("", "Loop Closure:");
   if (visibleClosure) {
@@ -14660,10 +15437,10 @@ function projectLoopSummary(liveDoc, pendingPrompts = [], options) {
   return lines.join("\n");
 }
 function projectHeapSummary(heap, options) {
-  const heapRecord = asRecord2(heap) || {};
-  const entriesByPath = asRecord2(heapRecord.entriesByPath) || {};
-  const listsByName = asRecord2(heapRecord.listsByName) || {};
-  const variablesByName = asRecord2(heapRecord.variablesByName) || {};
+  const heapRecord = asRecord4(heap) || {};
+  const entriesByPath = asRecord4(heapRecord.entriesByPath) || {};
+  const listsByName = asRecord4(heapRecord.listsByName) || {};
+  const variablesByName = asRecord4(heapRecord.variablesByName) || {};
   const focusedVariableNames = new Set(
     uniqueStrings(options?.focus?.variableNames || [])
   );
@@ -14678,7 +15455,7 @@ function projectHeapSummary(heap, options) {
   const maxVariables = options?.maxVariables ?? (hasFocus ? 4 : 6);
   const maxLists = options?.maxLists ?? (hasFocus ? 3 : 4);
   const maxEntries = options?.maxEntries ?? (hasFocus ? 5 : 6);
-  const variables = suppressRecentFallback ? [] : Object.values(variablesByName).map((value) => asRecord2(value)).filter((value) => Boolean(value)).sort((left, right) => {
+  const variables = suppressRecentFallback ? [] : Object.values(variablesByName).map((value) => asRecord4(value)).filter((value) => Boolean(value)).sort((left, right) => {
     const leftFocused = left.name && focusedVariableNames.has(left.name) ? 1 : 0;
     const rightFocused = right.name && focusedVariableNames.has(right.name) ? 1 : 0;
     return rightFocused - leftFocused || (right.updatedAt || 0) - (left.updatedAt || 0);
@@ -14692,7 +15469,7 @@ function projectHeapSummary(heap, options) {
   for (const variable of variables) {
     if (variable.entryPath) referencedPaths.add(variable.entryPath);
     if (variable.listName) {
-      const list = asRecord2(
+      const list = asRecord4(
         listsByName[variable.listName]
       );
       for (const path2 of list?.paths || []) referencedPaths.add(path2);
@@ -14701,10 +15478,10 @@ function projectHeapSummary(heap, options) {
   for (const path2 of focusedEntryPaths) {
     referencedPaths.add(path2);
   }
-  const visibleLists = Object.values(listsByName).map((value) => asRecord2(value)).filter((value) => Boolean(value)).filter(
+  const visibleLists = Object.values(listsByName).map((value) => asRecord4(value)).filter((value) => Boolean(value)).filter(
     (list) => variables.some((variable) => variable.listName === list.name) || Boolean(list.name && focusedListNames.has(list.name))
   ).sort((left, right) => (right.updatedAt || 0) - (left.updatedAt || 0)).slice(0, maxLists);
-  const visibleEntries = Object.values(entriesByPath).map((value) => asRecord2(value)).filter((value) => Boolean(value)).filter((entry) => entry.path && referencedPaths.has(entry.path)).sort((left, right) => (right.updatedAt || 0) - (left.updatedAt || 0)).slice(0, maxEntries);
+  const visibleEntries = Object.values(entriesByPath).map((value) => asRecord4(value)).filter((value) => Boolean(value)).filter((entry) => entry.path && referencedPaths.has(entry.path)).sort((left, right) => (right.updatedAt || 0) - (left.updatedAt || 0)).slice(0, maxEntries);
   const lines = [];
   lines.push("Variables:");
   if (variables.length === 0) {
@@ -14718,7 +15495,7 @@ function projectHeapSummary(heap, options) {
         continue;
       }
       if (variable.kind === "entry") {
-        const entry = variable.entryPath ? asRecord2(
+        const entry = variable.entryPath ? asRecord4(
           entriesByPath[variable.entryPath]
         ) : null;
         lines.push(
@@ -14726,7 +15503,7 @@ function projectHeapSummary(heap, options) {
         );
         continue;
       }
-      const list = variable.listName ? asRecord2(listsByName[variable.listName]) : null;
+      const list = variable.listName ? asRecord4(listsByName[variable.listName]) : null;
       lines.push(
         `- ${variable.name}: list<${variable.className || list?.className || "unknown"}> -> ${(list?.paths || []).length} item(s)`
       );
@@ -14759,7 +15536,7 @@ function createHarnessVerifierSnapshot(input) {
     input.projectionOptions
   );
   const heapDigest = hashString(
-    projectHeapSummary(asRecord2(input.liveDoc?.heap), {
+    projectHeapSummary(asRecord4(input.liveDoc?.heap), {
       focus: workflowFocus
     })
   ) || "00000000";
@@ -15085,246 +15862,12 @@ ${loopBlock}
 - 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 ENTRY_KEY_CANDIDATES = ["entryPath", "path"];
-var ENTRY_ARRAY_KEY_CANDIDATES = ["entryPaths", "paths"];
-var LIST_KEY_CANDIDATES = ["listName"];
-var LIST_ARRAY_KEY_CANDIDATES = ["listNames"];
-var VARIABLE_KEY_CANDIDATES = ["variableName"];
-var VARIABLE_ARRAY_KEY_CANDIDATES = ["variableNames"];
-var UI_CONTAINER_KEYS = ["show", "display", "present", "ui"];
-function asRecord3(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  return value;
-}
-function normalizeText(value) {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
-    return null;
-  }
-  return trimmed;
-}
-function humanTextFromStdout(stdout) {
-  for (const line of [...stdout].reverse()) {
-    const normalized = normalizeText(line);
-    if (!normalized) continue;
-    if (/^[A-Z_]+:/.test(normalized)) continue;
-    return normalized;
-  }
-  return null;
-}
-function pushString(target, value) {
-  if (typeof value === "string" && value.trim()) {
-    target.add(value.trim());
-  }
-}
-function pushStringArray(target, value) {
-  if (!Array.isArray(value)) return;
-  for (const item of value) {
-    pushString(target, item);
-  }
-}
-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]);
-}
-function scanForHeapReferences(value, heap, refs, depth = 0, seen = /* @__PURE__ */ new Set()) {
-  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);
-    if (heap.listsByName?.[trimmed]) refs.listNames.add(trimmed);
-    if (heap.variablesByName?.[trimmed]) refs.variableNames.add(trimmed);
-    return;
-  }
-  if (Array.isArray(value)) {
-    seen.add(value);
-    for (const item of value.slice(0, 24)) {
-      scanForHeapReferences(item, heap, refs, depth + 1, seen);
-    }
-    return;
-  }
-  const record = asRecord3(value);
-  if (!record) return;
-  seen.add(value);
-  collectReferencesFromRecord(record, refs);
-  for (const key of UI_CONTAINER_KEYS) {
-    const nested = asRecord3(record[key]);
-    if (nested) collectReferencesFromRecord(nested, refs);
-  }
-  for (const nested of Object.values(record).slice(0, 24)) {
-    scanForHeapReferences(nested, heap, refs, depth + 1, seen);
-  }
-}
-function resolveVariablesToReferences(variableNames, heap, refs) {
-  for (const variableName of variableNames) {
-    const variable = heap.variablesByName?.[variableName];
-    if (!variable) continue;
-    if (variable.kind === "entry" && variable.entryPath) {
-      refs.entryPaths.add(variable.entryPath);
-    }
-    if (variable.kind === "list" && variable.listName) {
-      refs.listNames.add(variable.listName);
-    }
-  }
-}
-function sortEntries(entries) {
-  return [...entries].sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
-}
-function sortLists(lists) {
-  return [...lists].sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
-}
-function dedupeEntries(entries) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const entry of entries) {
-    if (!entry?.path || seen.has(entry.path)) continue;
-    seen.add(entry.path);
-    result.push(entry);
-  }
-  return result;
-}
-function dedupeLists(lists) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const list of lists) {
-    if (!list?.name || seen.has(list.name)) continue;
-    seen.add(list.name);
-    result.push(list);
-  }
-  return result;
-}
-function extractResponseText(result, stdout) {
-  const directText = normalizeText(result);
-  if (directText) return directText;
-  const record = asRecord3(result);
-  if (record) {
-    for (const key of RESPONSE_KEYS) {
-      const normalized = normalizeText(record[key]);
-      if (normalized) return normalized;
-    }
-    for (const containerKey of UI_CONTAINER_KEYS) {
-      const nested = asRecord3(record[containerKey]);
-      if (!nested) continue;
-      for (const key of RESPONSE_KEYS) {
-        const normalized = normalizeText(nested[key]);
-        if (normalized) return normalized;
-      }
-    }
-  }
-  return humanTextFromStdout(stdout);
-}
-function fallbackResponseText(entries, lists) {
-  if (entries.length > 0) {
-    return entries.length === 1 ? "I found one relevant record." : `I found ${entries.length} relevant records.`;
-  }
-  if (lists.length > 0) {
-    const emptyOnly = lists.every((list) => (list.paths || []).length === 0);
-    if (emptyOnly) {
-      return lists.length === 1 ? "I saved one empty result set." : `I saved ${lists.length} empty result sets.`;
-    }
-    return lists.length === 1 ? "I saved one result set." : `I saved ${lists.length} result sets.`;
-  }
-  return null;
-}
-function getJobRelatedEntries(heap, jobId) {
-  return sortEntries(
-    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)
-    )
-  );
-}
-function entriesFromLists(lists, heap) {
-  const entries = [];
-  for (const list of lists) {
-    for (const path2 of list.paths || []) {
-      const entry = heap.entriesByPath?.[path2];
-      if (entry) entries.push(entry);
-    }
-  }
-  return entries;
-}
-function resolveJobPresentation({
-  jobId,
-  result,
-  stdout = [],
-  sessionHeap,
-  allowExplicitArtifacts = true
-}) {
-  const refs = {
-    entryPaths: /* @__PURE__ */ new Set(),
-    listNames: /* @__PURE__ */ new Set(),
-    variableNames: /* @__PURE__ */ new Set()
-  };
-  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))
-  );
-  const referencedEntries = sortEntries(
-    [...refs.entryPaths].map((path2) => sessionHeap.entriesByPath?.[path2]).filter((entry) => Boolean(entry))
-  );
-  const jobLists = getJobRelatedLists(sessionHeap, jobId);
-  const jobEntries = getJobRelatedEntries(sessionHeap, jobId);
-  const changedEntries = dedupeEntries([
-    ...jobEntries,
-    ...entriesFromLists(jobLists, sessionHeap)
-  ]);
-  const explicitLists = dedupeLists(referencedLists);
-  const explicitEntries = dedupeEntries([
-    ...referencedEntries,
-    ...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,
-    hasExplicitArtifacts
-  };
-}
-
 // src/agent-evals.ts
 var DEFAULT_CONTROLLER_BUDGETS = {
   maxIterations: 6,
   maxNoProgressIterations: 2
 };
-function asRecord4(value) {
+function asRecord5(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   return value;
 }
@@ -15372,7 +15915,7 @@ function buildArtifactDir(baseDir, suiteName = "granular-agent-evals") {
 function createTimestampedArtifactDirectory(options) {
   return buildArtifactDir(options?.baseDir, options?.suiteName);
 }
-function asArray2(value) {
+function asArray3(value) {
   if (!value) return [];
   return Array.isArray(value) ? value : [value];
 }
@@ -15390,7 +15933,7 @@ function buildScenarioSteps(scenario) {
     request: scenario.request,
     human: scenario.human,
     expect: scenario.expect,
-    inspect: [...asArray2(scenario.inspect), ...asArray2(scenario.verify)],
+    inspect: [...asArray3(scenario.inspect), ...asArray3(scenario.verify)],
     check: scenario.check,
     maxIterations: scenario.maxIterations,
     setup: {
@@ -15431,12 +15974,12 @@ function buildHistory(entries) {
   );
 }
 function getOpenPromptsFromDoc(liveDoc) {
-  const jobsById = asRecord4(asRecord4(liveDoc?.jobs)?.byId) || {};
+  const jobsById = asRecord5(asRecord5(liveDoc?.jobs)?.byId) || {};
   const prompts = [];
   for (const job of Object.values(jobsById)) {
-    const promptRecords = asRecord4(asRecord4(job)?.prompts) || {};
+    const promptRecords = asRecord5(asRecord5(job)?.prompts) || {};
     for (const raw of Object.values(promptRecords)) {
-      const record = asRecord4(raw);
+      const record = asRecord5(raw);
       if (!record || record.status !== "open" || typeof record.promptId !== "string")
         continue;
       const prompt = normalizePrompt({
@@ -15457,11 +16000,11 @@ function getOpenPromptsFromDoc(liveDoc) {
   return prompts;
 }
 function filterPromptsByBoundary(liveDoc, prompts, boundaryTimestamp) {
-  const jobsById = asRecord4(asRecord4(liveDoc?.jobs)?.byId) || {};
+  const jobsById = asRecord5(asRecord5(liveDoc?.jobs)?.byId) || {};
   return prompts.filter((prompt) => {
     for (const jobRecord of Object.values(jobsById)) {
-      const promptsById = asRecord4(asRecord4(jobRecord)?.prompts) || {};
-      const promptRecord = asRecord4(promptsById[prompt.id]);
+      const promptsById = asRecord5(asRecord5(jobRecord)?.prompts) || {};
+      const promptRecord = asRecord5(promptsById[prompt.id]);
       const openedAt = Number(promptRecord?.openedAt) || 0;
       if (openedAt >= boundaryTimestamp) return true;
     }
@@ -15554,10 +16097,10 @@ ${modelOutputInstruction()}`
           );
         }
         const raw = await response.json();
-        const content = asRecord4(
-          asRecord4(raw.choices?.[0])?.message
+        const content = asRecord5(
+          asRecord5(raw.choices?.[0])?.message
         )?.content;
-        const text = typeof content === "string" ? content : Array.isArray(content) ? content.map((part) => asRecord4(part)?.text || "").join("") : "";
+        const text = typeof content === "string" ? content : Array.isArray(content) ? content.map((part) => asRecord5(part)?.text || "").join("") : "";
         const parsed = extractJsonObject(text);
         if (!parsed) {
           if (attempt < 3) {
@@ -15609,17 +16152,17 @@ async function withTimeout(promise, ms, label) {
   }
 }
 function getActionSummary(liveDoc, jobId) {
-  const jobsById = asRecord4(asRecord4(liveDoc?.jobs)?.byId) || {};
-  const job = asRecord4(jobsById[jobId]);
+  const jobsById = asRecord5(asRecord5(liveDoc?.jobs)?.byId) || {};
+  const job = asRecord5(jobsById[jobId]);
   return Array.isArray(job?.actionSummary) ? job.actionSummary.filter(
     (line) => typeof line === "string"
   ) : [];
 }
 function normalizeHeapSnapshot2(heap) {
   return {
-    entriesByPath: asRecord4(heap?.entriesByPath) || {},
-    listsByName: asRecord4(heap?.listsByName) || {},
-    variablesByName: asRecord4(heap?.variablesByName) || {},
+    entriesByPath: asRecord5(heap?.entriesByPath) || {},
+    listsByName: asRecord5(heap?.listsByName) || {},
+    variablesByName: asRecord5(heap?.variablesByName) || {},
     updatedAt: typeof heap?.updatedAt === "number" ? heap.updatedAt : Date.now()
   };
 }
@@ -15805,8 +16348,8 @@ async function runAgentEvalSuite(options) {
             );
           }
           const inspectionResults = [];
-          const stepChecks = asArray2(step.check);
-          const stepInspections = asArray2(step.inspect);
+          const stepChecks = asArray3(step.check);
+          const stepInspections = asArray3(step.inspect);
           const context = {
             conversation,
             environment: conversation.environment,
@@ -15819,7 +16362,7 @@ async function runAgentEvalSuite(options) {
             promptInteractions: completed.promptInteractions,
             result: completed.result,
             heap: normalizeHeapSnapshot2(
-              asRecord4(
+              asRecord5(
                 cloneJson(conversation.environment.document)?.heap
               )
             ),
@@ -16030,7 +16573,7 @@ function createAgentEvalHarness(options) {
   }
   function buildCheckContext(conversation, completed, turnDir) {
     const liveDoc = cloneJson(conversation.environment.document);
-    const heap = normalizeHeapSnapshot2(asRecord4(liveDoc?.heap));
+    const heap = normalizeHeapSnapshot2(asRecord5(liveDoc?.heap));
     return {
       conversation,
       environment: conversation.environment,
@@ -16106,7 +16649,7 @@ function createAgentEvalHarness(options) {
       jobId: pending.job.id,
       result: resumed.result,
       stdout: [...pending.stdout, ...resumed.stdout],
-      sessionHeap: normalizeHeapSnapshot2(asRecord4(liveDoc?.heap))
+      sessionHeap: normalizeHeapSnapshot2(asRecord5(liveDoc?.heap))
     });
     const responseText = presentation.responseText || pending.finalReply || "Done.";
     pending.conversation.history.push({
@@ -16316,7 +16859,7 @@ function createAgentEvalHarness(options) {
       const settledLiveDoc = cloneJson(
         conversation.environment.document
       );
-      const sessionHeap = normalizeHeapSnapshot2(asRecord4(settledLiveDoc?.heap));
+      const sessionHeap = normalizeHeapSnapshot2(asRecord5(settledLiveDoc?.heap));
       const presentation = resolveJobPresentation({
         jobId: job.id,
         result: outcome.result,