@elench/testkit 0.1.111 → 0.1.113

package/README.md

@@ -2,7 +2,7 @@
 
 `@elench/testkit` discovers `*.testkit.ts` files, infers suite ownership from the
 filesystem, starts local services, provisions Docker-managed local Postgres
-databases, and runs HTTP, DAL, and Playwright suites.
+databases, and runs test suites.
 
 The package is now driven by `testkit.config.ts`, not `testkit.config.json`.
 

package/lib/bundler/index.mjs

@@ -11,6 +11,7 @@ const ROOT_ENTRY = path.join(PACKAGE_ROOT, "lib", "index.mjs");
 const CONFIG_ENTRY = path.join(PACKAGE_ROOT, "lib", "config-api", "index.mjs");
 const RUNTIME_ENTRY = path.join(PACKAGE_ROOT, "lib", "runtime", "index.mjs");
 const MANIFEST_FILE = "manifest.json";
+const BUNDLE_WRAPPER_VERSION = "summary-check-artifacts-v2";
 const bundleCache = new Map();
 
 export async function bundleK6File({
@@ -105,7 +106,9 @@ async function buildCacheMetadata(sourceFile, configFile = null) {
     .update("\0")
     .update(source)
     .update("\0")
-    .update(packageJsonText);
+    .update(packageJsonText)
+    .update("\0")
+    .update(BUNDLE_WRAPPER_VERSION);
   let configHash = null;
 
   if (configFile && fs.existsSync(configFile)) {
@@ -119,6 +122,7 @@ async function buildCacheMetadata(sourceFile, configFile = null) {
     cacheKey: hash.digest("hex"),
     sourceHash,
     configHash,
+    wrapperVersion: BUNDLE_WRAPPER_VERSION,
     testkitVersion: packageJson.version || null,
   };
 }
@@ -169,6 +173,96 @@ export function setup(...args) {
 export default function exec(...args) {
   return suite.exec(...args);
 }
+export function handleSummary(data) {
+  const checksData = extractChecksFromSummary(data);
+  emitTestkitArtifact("checks", checksData, {
+    kind: "testkit.checks",
+    summary: checksData.summary
+      ? \`\${checksData.summary.passed}/\${checksData.summary.total} checks passed\`
+      : "no checks",
+  });
+  return {};
+}
+
+function extractChecksFromSummary(data) {
+  const checks = [];
+  collectChecksRecursive(data && data.root_group, [], checks);
+  const total = checks.length;
+  const passed = checks.filter((c) => c.passes > 0 && c.fails === 0).length;
+
+  const thresholds = {};
+  for (const [name, metric] of Object.entries((data && data.metrics) || {})) {
+    if (metric && metric.thresholds) {
+      thresholds[name] = Object.entries(metric.thresholds).map(([expr, result]) => ({
+        expression: expr,
+        ok: Boolean(result && result.ok),
+      }));
+    }
+  }
+
+  const http = {};
+  for (const key of ["http_reqs", "http_req_duration", "http_req_failed"]) {
+    if (data && data.metrics && data.metrics[key]) {
+      http[key] = data.metrics[key].values || {};
+    }
+  }
+
+  return { checks, summary: { total, passed, failed: total - passed }, thresholds, http };
+}
+
+function collectChecksRecursive(group, path, out) {
+  if (!group) return;
+  const currentPath = normalizeNonEmptyString(group.name) ? [...path, normalizeNonEmptyString(group.name)] : path;
+  for (const check of Object.values(group.checks || {})) {
+    if (!check) continue;
+    out.push({
+      name: normalizeNonEmptyString(check.name) || "unnamed",
+      path: currentPath,
+      passes: normalizeCount(check.passes),
+      fails: normalizeCount(check.fails),
+    });
+  }
+  for (const subGroup of Object.values(group.groups || {})) {
+    collectChecksRecursive(subGroup, currentPath, out);
+  }
+}
+
+const TESTKIT_ARTIFACT_MARKER = "TESTKIT_ARTIFACT:";
+
+function emitTestkitArtifact(name, data, options = {}) {
+  const payload = encodeURIComponent(JSON.stringify({
+    name: normalizeArtifactName(name),
+    kind: normalizeOptionalString(options.kind),
+    summary: normalizeOptionalString(options.summary),
+    contentType: normalizeOptionalString(options.contentType) || "application/json",
+    data,
+    emittedAt: new Date().toISOString(),
+  }));
+  console.log(\`\${TESTKIT_ARTIFACT_MARKER}\${payload}\`);
+}
+
+function normalizeArtifactName(name) {
+  const normalized = normalizeNonEmptyString(name);
+  if (!normalized) {
+    throw new Error("emitArtifact(name, data) requires a non-empty artifact name");
+  }
+  return normalized;
+}
+
+function normalizeOptionalString(value) {
+  if (value === undefined || value === null) return null;
+  const normalized = String(value).trim();
+  return normalized.length > 0 ? normalized : null;
+}
+
+function normalizeNonEmptyString(value) {
+  return normalizeOptionalString(value);
+}
+
+function normalizeCount(value) {
+  const count = Number(value);
+  return Number.isFinite(count) && count > 0 ? count : 0;
+}
 
 function normalizeTestkitSuite(module) {
   const candidate = module?.default;

package/lib/cli/args.mjs

@@ -6,7 +6,7 @@ import {
   parseWorkersOption,
 } from "../runner/execution-config.mjs";
 
-export const POSITIONAL_TYPES = new Set(publicTestTypeList({ includeAll: true, includeLegacy: true }));
+export const POSITIONAL_TYPES = new Set(publicTestTypeList({ includeAll: true }));
 export const LIFECYCLE = new Set(["status", "destroy", "cleanup"]);
 export const RESERVED = new Set([...POSITIONAL_TYPES, ...LIFECYCLE]);
 

package/lib/cli/assistant/app.mjs

@@ -2,15 +2,16 @@ import React, { createElement, useEffect, useMemo, useRef, useState } from "reac
 import { Box, Text, useApp, useBoxMetrics, useCursor, useInput, useStdout } from "ink";
 import { bold, cyan, dim, green, red, yellow } from "../terminal/colors.mjs";
 import { RunTreeView } from "../components/blocks/run-tree.mjs";
-import { CodeBlock } from "./code-block.mjs";
+import { colorCodeLine } from "./code-block.mjs";
 import { getComposerDisplayModel } from "./composer.mjs";
 import { MarkdownBlock } from "./markdown-block.mjs";
 import { QualitySignalStrip } from "./quality-signal-strip.mjs";
 import { buildAssistantViewModel } from "./view-model.mjs";
-import { truncateText, wrapText } from "../terminal/layout.mjs";
+import { truncateText } from "../terminal/layout.mjs";
 
 const FALLBACK_COMMAND_BLOCK_WIDTH = 100;
 const COMMAND_BLOCK_CHROME_WIDTH = 4;
+const COMMAND_BLOCK_BODY_ROWS = 8;
 
 export function AssistantApp({
   assistantState,
@@ -58,6 +59,10 @@ export function AssistantApp({
   const runSession = assistantState.getLiveRunSession?.() || assistantState.getLastRunSession?.() || null;
   const serializedRunSession = snapshot.liveRunSession || snapshot.lastRunSession || null;
   const runSessionProductDir = serializedRunSession?.productDir || runSession?.productDir || snapshot.productDir;
+  const visibleBlocks = useMemo(
+    () => runSession ? view.blocks.filter((block) => !isRunCommandBlock(block)) : view.blocks,
+    [runSession, view.blocks]
+  );
 
   return createElement(
     Box,
@@ -70,9 +75,9 @@ export function AssistantApp({
         })
       : null,
     createElement(HeaderChrome, { view }),
-    view.blocks.length === 0
+    visibleBlocks.length === 0
       ? createElement(WelcomePanel, { view })
-      : createElement(Transcript, { view }),
+      : createElement(Transcript, { view: { ...view, blocks: visibleBlocks } }),
     runSession
       ? createElement(
           Box,
@@ -105,6 +110,12 @@ export function AssistantApp({
   );
 }
 
+function isRunCommandBlock(block) {
+  if (!block || block.kind !== "testkit-run") return false;
+  const command = String(block.command || "").trim();
+  return /^testkit\s+(run\s+)?(ui|e2e|scenario|int|dal|load|all|run)\b/.test(command);
+}
+
 function HeaderChrome({ view }) {
   const provider = view.welcome.rows.find(([label]) => label === "Provider")?.[1] || "";
   return createElement(
@@ -257,12 +268,16 @@ function renderCommandBlock(block, view = {}) {
     : block.outputPreview?.omittedLineCount || block.omittedOutputLineCount || 0;
   const blockWidth = Math.max(1, Number(view.terminalWidth) || FALLBACK_COMMAND_BLOCK_WIDTH);
   const contentWidth = Math.max(1, blockWidth - COMMAND_BLOCK_CHROME_WIDTH);
-  const commandLines = command ? wrapText(`${dim("$")} ${command}`, contentWidth) : [];
+  const commandLine = command ? truncateText(`${dim("$")} ${command}`, contentWidth) : null;
   const statusLine = status ? truncateText(status, contentWidth) : null;
-  const previewLines = outputLines.map((line) => truncateText(line, contentWidth));
-  const omittedLine = omitted > 0
-    ? truncateText(`… ${omitted} more line${omitted === 1 ? "" : "s"} omitted`, contentWidth)
-    : null;
+  const bodyRows = buildCommandBodyRows({
+    commandLine,
+    statusLine,
+    codeBlock,
+    outputLines,
+    omitted,
+    contentWidth,
+  });
 
   return [
     createElement(
@@ -277,21 +292,56 @@ function renderCommandBlock(block, view = {}) {
         width: blockWidth,
       },
       createElement(Text, { key: "title" }, `${marker} ${title}`),
-      ...commandLines.map((line, index) => createElement(Text, { key: `command-${index}` }, line)),
-      statusLine ? createElement(Text, { key: "status" }, colorCommandStatus(block, statusLine)) : null,
-      codeBlock ? createElement(Text, { key: "code-gap" }, "") : null,
-      ...(codeBlock ? CodeBlock({ lines: codeBlock.lines, language: codeBlock.language, width: contentWidth }) : []),
-      ...previewLines.map((line, index) => (
-        createElement(Text, { key: `output-${index}` }, dim(line))
-      )),
-      omittedLine ? createElement(Text, { key: "omitted" }, dim(omittedLine)) : null,
-      block.text && !command && outputLines.length === 0
-        ? createElement(Text, { key: "text" }, colorBlockText(block, truncateText(block.text, contentWidth)))
-        : null
+      ...bodyRows.map((row, index) => renderCommandBodyRow(block, row, index)),
     ),
   ];
 }
 
+function buildCommandBodyRows({ commandLine, statusLine, codeBlock, outputLines = [], omitted = 0, contentWidth }) {
+  const rows = [];
+  if (commandLine) rows.push({ tone: "command", text: commandLine });
+  if (statusLine) rows.push({ tone: "status", text: statusLine });
+
+  if (codeBlock) {
+    const available = Math.max(0, COMMAND_BLOCK_BODY_ROWS - rows.length - (omitted > 0 ? 1 : 0));
+    for (const line of (codeBlock.lines || []).slice(0, available)) {
+      rows.push({ tone: "code", language: codeBlock.language, text: truncateText(line, contentWidth) });
+    }
+    const omittedCount = Math.max(omitted, (codeBlock.lines || []).length - available);
+    if (omittedCount > 0 && rows.length < COMMAND_BLOCK_BODY_ROWS) {
+      rows.push({ tone: "muted", text: truncateText(`… ${omittedCount} more line${omittedCount === 1 ? "" : "s"} omitted`, contentWidth) });
+    }
+  } else {
+    const available = Math.max(0, COMMAND_BLOCK_BODY_ROWS - rows.length - (omitted > 0 ? 1 : 0));
+    for (const line of outputLines.slice(0, available)) {
+      rows.push({ tone: "muted", text: truncateText(line, contentWidth) });
+    }
+    const omittedCount = Math.max(omitted, outputLines.length - available);
+    if (omittedCount > 0 && rows.length < COMMAND_BLOCK_BODY_ROWS) {
+      rows.push({ tone: "muted", text: truncateText(`… ${omittedCount} more line${omittedCount === 1 ? "" : "s"} omitted`, contentWidth) });
+    }
+  }
+
+  while (rows.length < COMMAND_BLOCK_BODY_ROWS) rows.push({ tone: "blank", text: "" });
+  return rows.slice(0, COMMAND_BLOCK_BODY_ROWS);
+}
+
+function renderCommandBodyRow(block, row, index) {
+  if (row.tone === "status") {
+    return createElement(Text, { key: `body-${index}` }, colorCommandStatus(block, row.text));
+  }
+  if (row.tone === "code") {
+    return createElement(Text, { key: `body-${index}` }, colorCodeLine(row.text, row.language));
+  }
+  if (row.tone === "muted") {
+    return createElement(Text, { key: `body-${index}` }, dim(row.text));
+  }
+  if (row.tone === "blank") {
+    return createElement(Text, { key: `body-${index}` }, "");
+  }
+  return createElement(Text, { key: `body-${index}` }, row.text);
+}
+
 function formatCommandLine(block) {
   if (!block.command) return null;
   if (typeof block.command === "string") return block.command;

package/lib/cli/assistant/command-normalize.mjs

@@ -0,0 +1,22 @@
+export function normalizeCommandLine(value) {
+  const text = unwrapShellCommand(value)
+    .replace(/\s+/g, " ")
+    .trim();
+  if (!text) return null;
+  return canonicalizeTestkitInvocation(text);
+}
+
+export function unwrapShellCommand(value) {
+  const text = String(value || "").trim();
+  const match = text.match(/(?:^|\s)(?:[^\s'"]*\/)?(?:bash|sh|zsh)\s+-lc\s+(['"])([\s\S]*)\1\s*$/);
+  if (!match) return text;
+  return match[2].replace(/\\(["'\\$`])/g, "$1").trim();
+}
+
+function canonicalizeTestkitInvocation(command) {
+  return command
+    .replace(/^npx\s+(?:--yes\s+|-y\s+)?testkit\b/, "testkit")
+    .replace(/^node(?:\s+--[^\s]+)*\s+(?:(?:\.?\.?\/)?[^\s]+\/)?(?:bin\/)?testkit(?:\.(?:mjs|js))?\b/, "testkit")
+    .replace(/^(?:(?:\.?\.?\/)?[^\s]+\/)?(?:bin\/)?testkit(?:\.(?:mjs|js))?\b/, "testkit")
+    .trim();
+}

package/lib/cli/assistant/command-observer.mjs

@@ -8,12 +8,14 @@ const OBSERVED_KINDS = new Set(["run", "discover", "status", "doctor", "typechec
 export function createAssistantCommandObserver({
   productDir,
   commandLog,
+  turnId = null,
   runState,
   onEvent,
   intervalMs = POLL_INTERVAL_MS,
 } = {}) {
   const seenResultFiles = new Set();
   const observedRunCommandIds = new Set();
+  const hydratedArtifactKeys = new Set();
   let timer = null;
   let running = false;
   let lastArtifactSignatures = new Map();
@@ -22,8 +24,9 @@ export function createAssistantCommandObserver({
   function start() {
     if (running) return;
     running = true;
+    commandLogOffset = currentCommandLogSize();
+    markExistingResultFilesSeen();
     lastArtifactSignatures = readArtifactSignatures();
-    scan();
     timer = setInterval(scan, intervalMs);
   }
 
@@ -66,7 +69,7 @@ export function createAssistantCommandObserver({
       } catch {
         continue;
       }
-      if (event.sessionId && commandLog.sessionId && event.sessionId !== commandLog.sessionId) continue;
+      if (!isCurrentObservation(event)) continue;
       if (event.type === "command_start" && isRunCommand(event)) {
         observedRunCommandIds.add(event.commandId);
       }
@@ -89,9 +92,12 @@ export function createAssistantCommandObserver({
       } catch {
         continue;
       }
-      if (document.sessionId && commandLog.sessionId && document.sessionId !== commandLog.sessionId) continue;
-      if (!OBSERVED_KINDS.has(document.kind)) continue;
+      if (!isCurrentObservation(document)) {
+        seenResultFiles.add(filePath);
+        continue;
+      }
       seenResultFiles.add(filePath);
+      if (!OBSERVED_KINDS.has(document.kind)) continue;
       if (document.kind === "run") {
         observedRunCommandIds.add(document.commandId);
         hydrateRunArtifact("command-result", document);
@@ -137,6 +143,9 @@ export function createAssistantCommandObserver({
   function hydrateRunArtifact(source, command = null) {
     const artifact = loadObservedRunArtifact(command);
     if (!artifact) return;
+    const key = artifactKey(source, command, artifact);
+    if (hydratedArtifactKeys.has(key)) return;
+    hydratedArtifactKeys.add(key);
     runState?.hydrateFromArtifact?.(artifact);
     onEvent?.({
       type: "observed-run-artifact",
@@ -157,6 +166,7 @@ export function createAssistantCommandObserver({
     const assistant = artifact?.provenance?.assistant || {};
     if (!assistant.sessionId || !assistant.commandId) return false;
     if (commandLog?.sessionId && assistant.sessionId !== commandLog.sessionId) return false;
+    if (turnId && assistant.turnId !== turnId) return false;
     return observedRunCommandIds.has(assistant.commandId);
   }
 
@@ -174,6 +184,29 @@ export function createAssistantCommandObserver({
     }
   }
 
+  function isCurrentObservation(entry) {
+    if (entry?.sessionId && commandLog?.sessionId && entry.sessionId !== commandLog.sessionId) return false;
+    if (turnId && entry?.turnId !== turnId) return false;
+    return true;
+  }
+
+  function markExistingResultFilesSeen() {
+    const resultDir = commandLog?.resultDir;
+    if (!resultDir || !fs.existsSync(resultDir)) return;
+    for (const entry of fs.readdirSync(resultDir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith(".json")) {
+        seenResultFiles.add(path.join(resultDir, entry.name));
+      }
+    }
+  }
+
+  function currentCommandLogSize() {
+    const commandLogPath = commandLog?.commandLogPath;
+    if (!commandLogPath) return 0;
+    const stat = safeStat(commandLogPath);
+    return stat?.size || 0;
+  }
+
   function safeStat(filePath) {
     try {
       return fs.statSync(filePath);
@@ -182,6 +215,18 @@ export function createAssistantCommandObserver({
     }
   }
 
+  function artifactKey(source, command, artifact) {
+    const assistant = artifact?.provenance?.assistant || {};
+    const runId = artifact?.run?.id || command?.result?.runArtifact?.run?.id || command?.artifact?.run?.id || "unknown-run";
+    return [
+      source,
+      assistant.sessionId || commandLog?.sessionId || "",
+      assistant.turnId || turnId || "",
+      assistant.commandId || command?.commandId || "",
+      runId,
+    ].join("|");
+  }
+
   return {
     start,
     stop,

package/lib/cli/assistant/command-results.mjs

@@ -6,6 +6,7 @@ export const ASSISTANT_SESSION_ENV = "TESTKIT_ASSISTANT_SESSION_ID";
 export const ASSISTANT_RESULT_DIR_ENV = "TESTKIT_ASSISTANT_RESULT_DIR";
 export const ASSISTANT_COMMAND_LOG_ENV = "TESTKIT_ASSISTANT_COMMAND_LOG";
 export const ASSISTANT_COMMAND_ID_ENV = "TESTKIT_ASSISTANT_COMMAND_ID";
+export const ASSISTANT_TURN_ENV = "TESTKIT_ASSISTANT_TURN_ID";
 export const ASSISTANT_WRAPPER_LOGGED_ENV = "TESTKIT_ASSISTANT_WRAPPER_LOGGED";
 
 export function createAssistantCommandContext({
@@ -15,6 +16,7 @@ export function createAssistantCommandContext({
   env = process.env,
 } = {}) {
   const sessionId = env[ASSISTANT_SESSION_ENV] || null;
+  const turnId = env[ASSISTANT_TURN_ENV] || null;
   const resultDir = env[ASSISTANT_RESULT_DIR_ENV] || null;
   const commandLogPath = env[ASSISTANT_COMMAND_LOG_ENV] || null;
   if (!sessionId && !resultDir && !commandLogPath) return null;
@@ -23,6 +25,7 @@ export function createAssistantCommandContext({
   const startedAt = new Date().toISOString();
   return {
     sessionId,
+    turnId,
     resultDir,
     commandLogPath,
     commandId,
@@ -103,6 +106,7 @@ export function writeAssistantCommandResult(context, payload = {}) {
       schemaVersion: 1,
       source: "testkit-command-result",
       sessionId: context.sessionId,
+      turnId: context.turnId,
       commandId: context.commandId,
       kind: context.kind,
       argv: context.argv,
@@ -128,7 +132,12 @@ export function appendAssistantCommandLog(context, event) {
     fs.mkdirSync(path.dirname(commandLogPath), { recursive: true });
     fs.appendFileSync(
       commandLogPath,
-      `${JSON.stringify({ timestamp: new Date().toISOString(), sessionId: context?.sessionId || null, ...event })}\n`,
+      `${JSON.stringify({
+        timestamp: new Date().toISOString(),
+        sessionId: context?.sessionId || null,
+        turnId: context?.turnId || null,
+        ...event,
+      })}\n`,
       "utf8"
     );
   } catch {

package/lib/cli/assistant/context-pack.mjs

@@ -8,6 +8,7 @@ import {
   ASSISTANT_COMMAND_LOG_ENV,
   ASSISTANT_RESULT_DIR_ENV,
   ASSISTANT_SESSION_ENV,
+  ASSISTANT_TURN_ENV,
   ASSISTANT_WRAPPER_LOGGED_ENV,
 } from "./command-results.mjs";
 
@@ -38,9 +39,11 @@ export function prepareAssistantContextPack({
   } = paths;
   fs.mkdirSync(binDir, { recursive: true });
   fs.mkdirSync(resultDir, { recursive: true });
-  writeJson(currentPath, {
+  let activeTurnId = null;
+  const currentDocument = {
     schemaVersion: 1,
     sessionId,
+    activeTurnId,
     contextDir,
     contextPath,
     commandLogPath,
@@ -48,7 +51,8 @@ export function prepareAssistantContextPack({
     providerEventsPath,
     providerRawPath,
     createdAt: new Date().toISOString(),
-  });
+  };
+  writeCurrent();
 
   function refresh() {
     const snapshot = runState?.getSnapshot?.() || {};
@@ -63,12 +67,12 @@ export function prepareAssistantContextPack({
       artifactPath: path.join(productDir, ".testkit", "results", "latest.json"),
     });
     writeJson(selectionPath, buildContextSelection(snapshot));
-    fs.writeFileSync(commandsPath, buildCommandsMarkdown(), "utf8");
-    fs.writeFileSync(focusedDetailPath, `${detailContent.lines.join("\n")}\n`, "utf8");
-    fs.writeFileSync(focusedLogsPath, `${logsContent.lines.join("\n")}\n`, "utf8");
-    fs.writeFileSync(focusedArtifactsPath, `${artifactsContent.lines.join("\n")}\n`, "utf8");
-    fs.writeFileSync(focusedSetupPath, `${setupContent.lines.join("\n")}\n`, "utf8");
-    fs.writeFileSync(
+    writeText(commandsPath, buildCommandsMarkdown());
+    writeText(focusedDetailPath, `${detailContent.lines.join("\n")}\n`);
+    writeText(focusedLogsPath, `${logsContent.lines.join("\n")}\n`);
+    writeText(focusedArtifactsPath, `${artifactsContent.lines.join("\n")}\n`);
+    writeText(focusedSetupPath, `${setupContent.lines.join("\n")}\n`);
+    writeText(
       contextPath,
       buildContextMarkdown(productDir, snapshot, {
         contextPath,
@@ -81,9 +85,8 @@ export function prepareAssistantContextPack({
         focusedArtifactsPath,
         focusedSetupPath,
       }),
-      "utf8"
     );
-    fs.writeFileSync(wrapperPath, buildWrapperScript({
+    if (!fs.existsSync(wrapperPath)) fs.writeFileSync(wrapperPath, buildWrapperScript({
       cliPath: resolveCliPath(),
       classifierUrl: resolveClassifierUrl(),
       sessionId,
@@ -93,7 +96,7 @@ export function prepareAssistantContextPack({
       encoding: "utf8",
       mode: 0o755,
     });
-    fs.chmodSync(wrapperPath, 0o755);
+    if (fs.existsSync(wrapperPath)) fs.chmodSync(wrapperPath, 0o755);
   }
 
   refresh();
@@ -117,11 +120,18 @@ export function prepareAssistantContextPack({
     focusedSetupPath,
     binDir,
     wrapperPath,
-    providerEnv(baseEnv = process.env) {
+    setActiveTurnId(turnId = null) {
+      activeTurnId = turnId ? String(turnId) : null;
+      currentDocument.activeTurnId = activeTurnId;
+      currentDocument.updatedAt = new Date().toISOString();
+      writeCurrent();
+    },
+    providerEnv(baseEnv = process.env, { turnId = activeTurnId } = {}) {
       return {
         ...baseEnv,
         PATH: [binDir, baseEnv?.PATH, process.env.PATH].filter(Boolean).join(path.delimiter),
         [ASSISTANT_SESSION_ENV]: sessionId,
+        [ASSISTANT_TURN_ENV]: turnId || "",
         [ASSISTANT_RESULT_DIR_ENV]: resultDir,
         [ASSISTANT_COMMAND_LOG_ENV]: commandLogPath,
       };
@@ -132,7 +142,12 @@ export function prepareAssistantContextPack({
       try {
         fs.appendFileSync(
           commandLogPath,
-          `${JSON.stringify({ timestamp: new Date().toISOString(), ...event })}\n`,
+          `${JSON.stringify({
+            timestamp: new Date().toISOString(),
+            sessionId,
+            turnId: activeTurnId,
+            ...event,
+          })}\n`,
           "utf8"
         );
       } catch {
@@ -140,6 +155,10 @@ export function prepareAssistantContextPack({
       }
     },
   };
+
+  function writeCurrent() {
+    writeJson(currentPath, currentDocument);
+  }
 }
 
 function resolveCliPath() {
@@ -160,10 +179,12 @@ import { classifyAssistantCommandKind } from ${JSON.stringify(classifierUrl)};
 const commandId = process.env.${ASSISTANT_COMMAND_ID_ENV} || \`cmd-\${Date.now()}-\${Math.random().toString(36).slice(2, 10)}\`;
 const commandLogPath = process.env.${ASSISTANT_COMMAND_LOG_ENV} || ${JSON.stringify(commandLogPath)};
 const sessionId = process.env.${ASSISTANT_SESSION_ENV} || ${JSON.stringify(sessionId)};
+const turnId = process.env.${ASSISTANT_TURN_ENV} || null;
 const argv = process.argv.slice(2);
 
 appendCommandLog({
   type: "command_start",
+  turnId,
   commandId,
   command: "testkit",
   kind: classifyAssistantCommandKind(argv),
@@ -177,6 +198,7 @@ const result = spawnSync(process.execPath, [${JSON.stringify(cliPath)}, ...proce
     ...process.env,
     TESTKIT_NO_ASSISTANT_DEFAULT: "1",
     ${ASSISTANT_SESSION_ENV}: sessionId,
+    ${ASSISTANT_TURN_ENV}: turnId || "",
     ${ASSISTANT_RESULT_DIR_ENV}: process.env.${ASSISTANT_RESULT_DIR_ENV} || ${JSON.stringify(resultDir)},
     ${ASSISTANT_COMMAND_LOG_ENV}: commandLogPath,
     ${ASSISTANT_COMMAND_ID_ENV}: commandId,
@@ -190,6 +212,7 @@ if (result.error) {
 }
 appendCommandLog({
   type: "command_exit",
+  turnId,
   commandId,
   command: "testkit",
   kind: classifyAssistantCommandKind(argv),
@@ -203,7 +226,7 @@ process.exit(result.status ?? 0);
 function appendCommandLog(event) {
   try {
     fs.mkdirSync(path.dirname(commandLogPath), { recursive: true });
-    fs.appendFileSync(commandLogPath, \`\${JSON.stringify({ timestamp: new Date().toISOString(), sessionId, ...event })}\\n\`, "utf8");
+    fs.appendFileSync(commandLogPath, \`\${JSON.stringify({ timestamp: new Date().toISOString(), sessionId, turnId, ...event })}\\n\`, "utf8");
   } catch {
     // Command observation must not affect command execution.
   }
@@ -284,5 +307,12 @@ function buildCommandsMarkdown() {
 }
 
 function writeJson(filePath, value) {
-  fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf8");
+  writeText(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function writeText(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tempPath, String(value), "utf8");
+  fs.renameSync(tempPath, filePath);
 }