u-foo 2.5.14 → 3.0.0

package/src/code/sessionStore.js

@@ -1,6 +1,21 @@
 const fs = require("fs");
 const path = require("path");
 const { randomUUID } = require("crypto");
+const {
+  getTranscriptsDir,
+  getTranscriptFilePath,
+  loadTranscript,
+  migrateNlMessagesToTranscript,
+  appendTranscriptMessages,
+  transcriptEventsToMessages,
+  deleteTranscript,
+} = require("./context/transcript");
+const { deleteSessionArtifacts } = require("./context/artifacts");
+const { deleteSessionCommitLog, maybeGcSessionArtifacts } = require("./context/artifactGc");
+const { defaultContextPolicy } = require("./context/assembler");
+const { emptyTaskContract } = require("./context/stateCommit");
+const { emptyWorkingSet } = require("./context/workingSet");
+const { emptyExecutionState } = require("./context/executionSegment");
 
 function getSessionsDir(workspaceRoot = process.cwd()) {
   const root = path.resolve(workspaceRoot || process.cwd());
@@ -40,21 +55,165 @@ function cloneMessages(value = []) {
   }
 }
 
+function normalizeContextPolicy(value = {}) {
+  const defaults = defaultContextPolicy();
+  const source = value && typeof value === "object" ? value : {};
+  return {
+    ...defaults,
+    ...source,
+    transcriptWindow: Number.isFinite(source.transcriptWindow)
+      ? Math.max(1, Math.floor(source.transcriptWindow))
+      : defaults.transcriptWindow,
+  };
+}
+
 function buildSessionSnapshot(input = {}) {
   const source = input && typeof input === "object" ? input : {};
   const sessionId = resolveSessionId(source.sessionId);
   const createdAt = String(source.createdAt || "").trim() || toIsoNow();
-  return {
-    version: 1,
+
+  const base = {
     sessionId,
     workspaceRoot: String(source.workspaceRoot || process.cwd()).trim() || process.cwd(),
     provider: String(source.provider || "").trim(),
     model: String(source.model || "").trim(),
     context: String(source.context || ""),
-    nlMessages: cloneMessages(source.nlMessages),
     createdAt,
     updatedAt: toIsoNow(),
   };
+
+  return {
+    version: 2,
+    ...base,
+    transcript: {
+      path: getTranscriptFilePath(base.workspaceRoot, sessionId),
+    },
+    artifacts: {
+      indexPath: path.join(base.workspaceRoot, ".ufoo", "agent", "ucode", "artifacts", sessionId),
+    },
+    contextPolicy: normalizeContextPolicy(source.contextPolicy),
+    summary: String(source.summary || "").trim(),
+    projectSnapshot: source.projectSnapshot && typeof source.projectSnapshot === "object"
+      ? source.projectSnapshot
+      : null,
+    taskContract: source.taskContract && typeof source.taskContract === "object"
+      ? source.taskContract
+      : emptyTaskContract(),
+    stateEpoch: source.stateEpoch && typeof source.stateEpoch === "object"
+      ? source.stateEpoch
+      : null,
+    workingSet: Array.isArray(source.workingSet) ? source.workingSet : emptyWorkingSet(),
+    executionState: source.executionState && typeof source.executionState === "object"
+      ? source.executionState
+      : emptyExecutionState(),
+    activeSkills: Array.isArray(source.activeSkills) ? source.activeSkills : [],
+    toolCallsSinceCommit: Number.isFinite(source.toolCallsSinceCommit)
+      ? Math.max(0, Math.floor(source.toolCallsSinceCommit))
+      : 0,
+    // In-memory compatibility for callers still reading nlMessages
+    nlMessages: cloneMessages(source.nlMessages),
+  };
+}
+
+function hydrateSessionFromDisk(snapshot = {}, workspaceRoot = process.cwd()) {
+  const payload = buildSessionSnapshot({
+    ...snapshot,
+    workspaceRoot: workspaceRoot || snapshot.workspaceRoot,
+  });
+  if (payload.version < 2) return payload;
+
+  const sessionId = payload.sessionId;
+  const transcript = loadTranscript(workspaceRoot, sessionId);
+  if (transcript.events.length > 0) {
+    const { transcriptEventsToMessages } = require("./context/transcript");
+    payload.nlMessages = transcriptEventsToMessages(transcript.events);
+    return payload;
+  }
+
+  if (Array.isArray(snapshot.nlMessages) && snapshot.nlMessages.length > 0) {
+    migrateNlMessagesToTranscript(workspaceRoot, sessionId, snapshot.nlMessages);
+    const reloaded = loadTranscript(workspaceRoot, sessionId);
+    const { transcriptEventsToMessages } = require("./context/transcript");
+    payload.nlMessages = transcriptEventsToMessages(reloaded.events);
+  }
+
+  return payload;
+}
+
+function syncTranscriptFromNlMessages(workspaceRoot = process.cwd(), sessionId = "", nlMessages = []) {
+  const messages = Array.isArray(nlMessages) ? nlMessages : [];
+  if (!sessionId || messages.length === 0) return;
+  const existing = loadTranscript(workspaceRoot, sessionId);
+  if (existing.events.length === 0) {
+    migrateNlMessagesToTranscript(workspaceRoot, sessionId, messages);
+    return;
+  }
+  const { matchTranscriptBaseline } = require("./context/assembler");
+  const priorMessages = transcriptEventsToMessages(existing.events);
+  const baseline = matchTranscriptBaseline(priorMessages, messages);
+  if (messages.length > baseline) {
+    appendTranscriptMessages(workspaceRoot, sessionId, messages.slice(baseline));
+  }
+}
+
+function listSessionSummaries(workspaceRoot = process.cwd(), { limit = 40 } = {}) {
+  const dir = getSessionsDir(workspaceRoot);
+  const cap = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 40;
+  if (!fs.existsSync(dir)) return [];
+  let names = [];
+  try {
+    names = fs.readdirSync(dir).filter((name) => name.endsWith(".json"));
+  } catch {
+    return [];
+  }
+
+  const rows = [];
+  for (const name of names) {
+    const filePath = path.join(dir, name);
+    let stat = null;
+    try {
+      stat = fs.statSync(filePath);
+    } catch {
+      continue;
+    }
+    let parsed = null;
+    try {
+      parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    } catch {
+      parsed = null;
+    }
+    const sessionId = normalizeSessionId(
+      (parsed && parsed.sessionId) || name.replace(/\.json$/i, ""),
+    );
+    if (!sessionId) continue;
+    const updatedAt = String(
+      (parsed && (parsed.updatedAt || parsed.createdAt))
+      || (stat && stat.mtime && stat.mtime.toISOString())
+      || "",
+    ).trim();
+    const summary = String((parsed && parsed.summary) || "").trim().replace(/\s+/g, " ");
+    const model = String((parsed && parsed.model) || "").trim();
+    const bits = [
+      updatedAt ? updatedAt.slice(0, 19).replace("T", " ") : "",
+      model,
+      summary ? summary.slice(0, 48) : "",
+    ].filter(Boolean);
+    rows.push({
+      id: sessionId,
+      cmd: sessionId,
+      alias: sessionId,
+      desc: bits.join(" · "),
+      updatedAt,
+      mtimeMs: stat && Number.isFinite(stat.mtimeMs) ? stat.mtimeMs : 0,
+    });
+  }
+
+  rows.sort((left, right) => {
+    const byTime = (right.mtimeMs || 0) - (left.mtimeMs || 0);
+    if (byTime !== 0) return byTime;
+    return String(left.id).localeCompare(String(right.id));
+  });
+  return rows.slice(0, cap);
 }
 
 function getSessionFilePath(workspaceRoot = process.cwd(), sessionId = "") {
@@ -79,20 +238,19 @@ function saveSessionSnapshot(workspaceRoot = process.cwd(), snapshot = {}) {
     };
   }
 
+  const toWrite = { ...payload };
+  if (toWrite.version >= 2) {
+    syncTranscriptFromNlMessages(normalizedRoot, payload.sessionId, payload.nlMessages);
+    // nlMessages live in transcript.jsonl; keep session.json light
+    delete toWrite.nlMessages;
+  }
+
   try {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    // Write to a temp file and rename so a crash mid-write cannot leave a
-    // corrupted session JSON behind.
+    fs.mkdirSync(getTranscriptsDir(normalizedRoot), { recursive: true });
     const tmpFile = `${filePath}.${process.pid}-${randomUUID()}.tmp`;
-    fs.writeFileSync(tmpFile, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    fs.writeFileSync(tmpFile, `${JSON.stringify(toWrite, null, 2)}\n`, "utf8");
     fs.renameSync(tmpFile, filePath);
-    return {
-      ok: true,
-      error: "",
-      sessionId: payload.sessionId,
-      filePath,
-      snapshot: payload,
-    };
   } catch (err) {
     return {
       ok: false,
@@ -101,6 +259,26 @@ function saveSessionSnapshot(workspaceRoot = process.cwd(), snapshot = {}) {
       filePath,
     };
   }
+
+  // Artifact GC is throttled (default 2m) so long sessions do not accumulate
+  // unbounded tool result files between explicit maintenance runs.
+  let artifactGc = null;
+  try {
+    artifactGc = maybeGcSessionArtifacts(normalizedRoot, payload.sessionId, {
+      ...(snapshot.artifactGc && typeof snapshot.artifactGc === "object" ? snapshot.artifactGc : {}),
+    });
+  } catch {
+    artifactGc = { ok: false, error: "artifact gc failed", skipped: true };
+  }
+
+  return {
+    ok: true,
+    error: "",
+    sessionId: payload.sessionId,
+    filePath,
+    snapshot: payload,
+    artifactGc,
+  };
 }
 
 function loadSessionSnapshot(workspaceRoot = process.cwd(), sessionId = "") {
@@ -130,12 +308,13 @@ function loadSessionSnapshot(workspaceRoot = process.cwd(), sessionId = "") {
   try {
     const raw = fs.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
-    const snapshot = buildSessionSnapshot({
+    const snapshot = hydrateSessionFromDisk({
       ...parsed,
       sessionId: normalizedId,
       workspaceRoot: normalizedRoot,
       createdAt: parsed && parsed.createdAt ? parsed.createdAt : "",
-    });
+      nlMessages: parsed && parsed.nlMessages ? parsed.nlMessages : [],
+    }, normalizedRoot);
     return {
       ok: true,
       error: "",
@@ -154,13 +333,36 @@ function loadSessionSnapshot(workspaceRoot = process.cwd(), sessionId = "") {
   }
 }
 
+function deleteSessionData(workspaceRoot = process.cwd(), sessionId = "") {
+  const normalizedId = normalizeSessionId(sessionId);
+  if (!normalizedId) return { ok: false, error: "invalid session id" };
+  const filePath = getSessionFilePath(workspaceRoot, normalizedId);
+  try {
+    if (filePath && fs.existsSync(filePath)) fs.unlinkSync(filePath);
+    deleteTranscript(workspaceRoot, normalizedId);
+    deleteSessionArtifacts(workspaceRoot, normalizedId);
+    deleteSessionCommitLog(workspaceRoot, normalizedId);
+    return { ok: true, error: "" };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err && err.message ? err.message : "failed to delete session data",
+    };
+  }
+}
+
 module.exports = {
   getSessionsDir,
+  getTranscriptsDir,
+  getTranscriptFilePath,
   normalizeSessionId,
   createSessionId,
   resolveSessionId,
   buildSessionSnapshot,
+  hydrateSessionFromDisk,
   getSessionFilePath,
   saveSessionSnapshot,
   loadSessionSnapshot,
+  listSessionSummaries,
+  deleteSessionData,
 };

package/src/code/skills/index.js

@@ -9,6 +9,12 @@ const {
 const {
   buildSkillInjections,
 } = require("./injection");
+const {
+  buildSkillManifest,
+  buildSkillManifests,
+  renderSkillManifestSection,
+  renderActiveSkillBlock,
+} = require("./manifest");
 
 function showSkill({ name = "", workspaceRoot = process.cwd(), asJson = false } = {}) {
   const outcome = listUcodeSkills({ workspaceRoot });
@@ -70,5 +76,9 @@ module.exports = {
   renderSkillsSection,
   formatSkillsList,
   buildSkillInjections,
+  buildSkillManifest,
+  buildSkillManifests,
+  renderSkillManifestSection,
+  renderActiveSkillBlock,
   showSkill,
 };

package/src/code/skills/injection.js

@@ -5,6 +5,10 @@ const {
   findSkillsByName,
   listUcodeSkills,
 } = require("./loader");
+const {
+  buildSkillManifest,
+  renderActiveSkillBlock,
+} = require("./manifest");
 
 function markdownSkillLinks(prompt = "") {
   const text = String(prompt || "");
@@ -71,9 +75,41 @@ function sanitizeSkillContent(content = "") {
   return text;
 }
 
-function readSkillBlock(skill) {
+function readSkillBlock(skill, options = {}) {
   const content = sanitizeSkillContent(fs.readFileSync(skill.path, "utf8"));
-  return `<skill>\n<name>${skill.name}</name>\n<path>${String(skill.path).replace(/\\/g, "/")}</path>\n${content}\n</skill>`;
+  const useActive = options.useActiveSkillTag === true;
+  const tag = useActive ? "active_skill" : "skill";
+  const bodyArtifactId = String(options.bodyArtifactId || "").trim();
+  const header = [
+    `<${tag}>`,
+    `<name>${skill.name}</name>`,
+    `<path>${String(skill.path).replace(/\\/g, "/")}</path>`,
+    bodyArtifactId ? `<bodyArtifactId>${bodyArtifactId}</bodyArtifactId>` : "",
+  ].filter(Boolean).join("\n");
+  return `${header}\n${content}\n</${tag}>`;
+}
+
+function persistSkillBodyArtifact(skill = {}, content = "", options = {}) {
+  const workspaceRoot = options.workspaceRoot || process.cwd();
+  const sessionId = String(options.sessionId || "").trim();
+  if (!sessionId) return "";
+  try {
+    const { saveArtifact } = require("../context/artifacts");
+    const saved = saveArtifact(workspaceRoot, sessionId, {
+      type: "skill_body",
+      tool: "skill",
+      source: skill.path || "",
+      args: { skill: skill.name || "" },
+      raw: { ok: true, path: skill.path || "", content: String(content || "") },
+      summary: `skill body ${skill.name || ""}`,
+      createdBy: "skill_injection",
+    });
+    return saved && saved.artifact && saved.artifact.artifactId
+      ? saved.artifact.artifactId
+      : "";
+  } catch {
+    return "";
+  }
 }
 
 function buildSkillInjections({
@@ -81,6 +117,9 @@ function buildSkillInjections({
   workspaceRoot = process.cwd(),
   skillsOutcome = null,
   loadSkills = listUcodeSkills,
+  sessionId = "",
+  persistBodies = false,
+  useActiveSkillTag = false,
 } = {}) {
   const outcome = skillsOutcome || loadSkills({ workspaceRoot });
   const skills = Array.isArray(outcome.skills) ? outcome.skills : [];
@@ -111,9 +150,28 @@ function buildSkillInjections({
   }
 
   const blocks = [];
+  const manifests = [];
+  const activeSkills = [];
   for (const skill of selected.values()) {
     try {
-      blocks.push(readSkillBlock(skill));
+      const rawContent = fs.readFileSync(skill.path, "utf8");
+      const content = sanitizeSkillContent(rawContent);
+      let bodyArtifactId = "";
+      if (persistBodies && sessionId) {
+        bodyArtifactId = persistSkillBodyArtifact(skill, content, { workspaceRoot, sessionId });
+      }
+      const manifest = buildSkillManifest(skill, { bodyArtifactId });
+      manifests.push(manifest);
+      activeSkills.push({
+        name: skill.name,
+        path: skill.path,
+        bodyArtifactId,
+      });
+      if (useActiveSkillTag) {
+        blocks.push(renderActiveSkillBlock(manifest, content));
+      } else {
+        blocks.push(readSkillBlock(skill, { bodyArtifactId, useActiveSkillTag: false }));
+      }
     } catch (err) {
       warnings.push(`failed to read skill ${skill.path}: ${err && err.message ? err.message : "read failed"}`);
     }
@@ -121,6 +179,8 @@ function buildSkillInjections({
 
   return {
     blocks,
+    manifests,
+    activeSkills,
     warnings,
     skills,
     errors: Array.isArray(outcome.errors) ? outcome.errors : [],
@@ -132,5 +192,8 @@ module.exports = {
   markdownSkillLinks,
   resolveSkillLinkTarget,
   findSkillByPath,
+  readSkillBlock,
+  persistSkillBodyArtifact,
   buildSkillInjections,
+  sanitizeSkillContent,
 };

package/src/code/skills/loader.js

@@ -98,11 +98,32 @@ function parseSkillFile(filePath, rootInfo = {}) {
       || data.shortDescription
       || ""
   ).trim();
+  const workflowSummary = String(
+    data.workflowSummary
+      || data["workflow-summary"]
+      || metadata.workflowSummary
+      || metadata["workflow-summary"]
+      || shortDescription
+      || ""
+  ).trim();
+  const triggersRaw = data.triggers != null
+    ? data.triggers
+    : (data.trigger != null
+      ? data.trigger
+      : (metadata.triggers != null ? metadata.triggers : metadata.trigger));
+  let triggers = [];
+  if (Array.isArray(triggersRaw)) {
+    triggers = triggersRaw.map((item) => String(item || "").trim()).filter(Boolean);
+  } else if (typeof triggersRaw === "string" && triggersRaw.trim()) {
+    triggers = triggersRaw.split(/[,|]/).map((item) => item.trim()).filter(Boolean);
+  }
 
   return {
     name,
     description,
     shortDescription,
+    workflowSummary,
+    triggers,
     path: skillPath,
     dir,
     scope: rootInfo.scope || "repo",

package/src/code/skills/manifest.js

@@ -0,0 +1,87 @@
+"use strict";
+
+function asStringList(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item || "").trim()).filter(Boolean);
+  }
+  if (typeof value === "string" && value.trim()) {
+    return value.split(/[,|]/).map((item) => item.trim()).filter(Boolean);
+  }
+  return [];
+}
+
+function buildSkillManifest(skill = {}, options = {}) {
+  const source = skill && typeof skill === "object" ? skill : {};
+  const bodyArtifactId = String(options.bodyArtifactId || source.bodyArtifactId || "").trim();
+  const triggers = Array.isArray(source.triggers) && source.triggers.length > 0
+    ? source.triggers.map(String).filter(Boolean)
+    : asStringList(source.trigger);
+  const workflowSummary = String(
+    source.workflowSummary
+      || source.shortDescription
+      || source.description
+      || "",
+  ).trim().slice(0, 400);
+
+  return {
+    name: String(source.name || "").trim(),
+    description: String(source.description || "").trim(),
+    shortDescription: String(source.shortDescription || "").trim(),
+    triggers,
+    workflowSummary,
+    path: String(source.path || "").replace(/\\/g, "/"),
+    scope: String(source.scope || "").trim(),
+    bodyArtifactId,
+  };
+}
+
+function buildSkillManifests(skills = [], options = {}) {
+  return (Array.isArray(skills) ? skills : [])
+    .filter((skill) => skill && skill.enabled !== false)
+    .map((skill) => buildSkillManifest(skill, options));
+}
+
+function renderSkillManifestSection(manifests = []) {
+  const list = Array.isArray(manifests) ? manifests.filter((m) => m && m.name) : [];
+  if (list.length === 0) return "";
+
+  const lines = [
+    "## Skill Manifests",
+    "Lightweight skill cards for selection. Full skill body loads only when a skill is explicitly activated.",
+  ];
+  for (const manifest of list) {
+    lines.push(`### ${manifest.name}`);
+    if (manifest.workflowSummary) lines.push(`- Workflow: ${manifest.workflowSummary}`);
+    if (manifest.triggers && manifest.triggers.length > 0) {
+      lines.push(`- Triggers: ${manifest.triggers.join(", ")}`);
+    }
+    if (manifest.bodyArtifactId) {
+      lines.push(`- Body artifact: artifact://${manifest.bodyArtifactId}`);
+    } else if (manifest.path) {
+      lines.push(`- Path: ${manifest.path}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+function renderActiveSkillBlock(manifest = {}, body = "") {
+  const name = String(manifest.name || "").trim() || "skill";
+  const pathText = String(manifest.path || "").replace(/\\/g, "/");
+  const bodyArtifactId = String(manifest.bodyArtifactId || "").trim();
+  const header = [
+    `<active_skill>`,
+    `<name>${name}</name>`,
+    pathText ? `<path>${pathText}</path>` : "",
+    bodyArtifactId ? `<bodyArtifactId>${bodyArtifactId}</bodyArtifactId>` : "",
+    manifest.workflowSummary ? `<workflowSummary>${manifest.workflowSummary}</workflowSummary>` : "",
+  ].filter(Boolean).join("\n");
+  return `${header}\n${String(body || "").trim()}\n</active_skill>`;
+}
+
+module.exports = {
+  asStringList,
+  buildSkillManifest,
+  buildSkillManifests,
+  renderSkillManifestSection,
+  renderActiveSkillBlock,
+};

package/src/code/skills/render.js

@@ -1,4 +1,9 @@
-function renderSkillsSection(skills = []) {
+const {
+  buildSkillManifests,
+  renderSkillManifestSection,
+} = require("./manifest");
+
+function renderSkillsSection(skills = [], options = {}) {
   const list = (Array.isArray(skills) ? skills : []).filter((skill) => skill && skill.enabled !== false);
   if (list.length === 0) return "";
 
@@ -19,6 +24,15 @@ function renderSkillsSection(skills = []) {
   lines.push("- When a skill is selected, read only the specific skill body and nearby referenced files needed for the task.");
   lines.push("- If a skill is ambiguous, missing, or unreadable, say so briefly and continue with the best fallback.");
 
+  if (options.includeManifests !== false) {
+    const manifests = buildSkillManifests(list);
+    const manifestSection = renderSkillManifestSection(manifests);
+    if (manifestSection) {
+      lines.push("");
+      lines.push(manifestSection);
+    }
+  }
+
   return lines.join("\n");
 }
 

package/src/code/taskDecomposer.js

@@ -4,6 +4,34 @@
  */
 
 const { runNativeAgentTask } = require("./nativeRunner");
+const { assembleModelContext, recordToolCallInSession } = require("./context/assembler");
+const fs = require("fs");
+const {
+  buildSkillManifest,
+  renderActiveSkillBlock,
+} = require("./skills");
+const { sanitizeSkillContent } = require("./skills/injection");
+
+function renderActiveSkillBodiesFromState(state = {}) {
+  const skills = Array.isArray(state.activeSkills) ? state.activeSkills : [];
+  const blocks = [];
+  for (const skill of skills) {
+    const skillPath = String(skill && skill.path || "").trim();
+    if (!skillPath) continue;
+    try {
+      const raw = fs.readFileSync(skillPath, "utf8");
+      const content = sanitizeSkillContent(raw);
+      const manifest = buildSkillManifest({
+        name: skill.name || "",
+        path: skillPath,
+      }, { bodyArtifactId: skill.bodyArtifactId || "" });
+      blocks.push(renderActiveSkillBlock(manifest, content));
+    } catch {
+      // ignore missing skill bodies
+    }
+  }
+  return blocks;
+}
 
 /**
  * Decompose a bug fix task into manageable steps
@@ -132,6 +160,8 @@ async function runDecomposedTask({
   systemPrompt,
   messages = [],
   sessionId = "",
+  state = null,
+  systemBlocks = null,
 }) {
   const steps = decomposeBugFixTask(task);
   const results = [];
@@ -165,19 +195,43 @@ async function runDecomposedTask({
     try {
       // Run the step with its own timeout
       const stepPrompt = buildStepPrompt(step, results);
+      let stepMessages = messages;
+      let stepSystemPrompt = systemPrompt;
+      let stepSystemBlocks = systemBlocks;
+      if (state) {
+        const skillBodies = renderActiveSkillBodiesFromState(state);
+        const assembled = assembleModelContext(state, {
+          workspaceRoot,
+          model,
+          provider,
+          turnDynamic: [...skillBodies, stepPrompt].filter(Boolean).join("\n\n"),
+        });
+        stepMessages = assembled.messages;
+        stepSystemPrompt = assembled.systemPrompt;
+        stepSystemBlocks = assembled.systemBlocks;
+      }
       const stepResult = await runNativeAgentTask({
         workspaceRoot,
         provider,
         model,
         prompt: stepPrompt,
-        systemPrompt,
-        messages,
+        systemPrompt: stepSystemPrompt,
+        systemBlocks: stepSystemBlocks,
+        messages: stepMessages,
         sessionId,
         timeoutMs: step.timeoutMs,
         onToolEvent,
         signal,
+        onArtifactPersisted: state
+          ? (persisted) => recordToolCallInSession(state, persisted, workspaceRoot)
+          : null,
       });
 
+      if (state && stepResult && Array.isArray(stepResult.messages)) {
+        const { syncMessagesToTranscript } = require("./context/assembler");
+        syncMessagesToTranscript(state, stepResult.messages, workspaceRoot);
+      }
+
       results.push({
         step: step.id,
         name: step.name,