@zq-silk/yui 0.13.10 → 0.14.1

package/dist/turn/turn.js

@@ -0,0 +1,356 @@
+import { validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
+import { validateTaskRecordReference } from "../task/taskRecordReference.js";
+import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
+import { createTurnInput, createTurnInputEnvelope, validateTurnInput } from "../context/turnInputContract.js";
+export function createTurn(id, taskId, roleName, mode, input, now, context) {
+    if (mode !== "new" && mode !== "resume") {
+        throw new Error(`Turn dispatch mode is invalid: ${mode}.`);
+    }
+    const timestamp = now.toISOString();
+    const normalizedInput = validateTurnInput(input);
+    return {
+        schemaVersion: 1,
+        id: requireSafeIdentity(id, "Turn id"),
+        taskId: requireSafeIdentity(taskId, "Task id"),
+        roleName: requireSafeIdentity(roleName, "Role name"),
+        mode,
+        inputs: [turnInputRecord(normalizedInput, 1, timestamp)],
+        purpose: context.purpose ?? "execution",
+        ...(context.workItemId === undefined
+            ? {}
+            : { workItemId: requireSafeIdentity(context.workItemId, "Work item id") }),
+        ...(context.reviewRoundId === undefined
+            ? {}
+            : { reviewRoundId: requireSafeIdentity(context.reviewRoundId, "ReviewRound id") }),
+        ...(context.executionGroupId === undefined
+            ? {}
+            : { executionGroupId: requireSafeIdentity(context.executionGroupId, "ExecutionGroup id") }),
+        ...(context.executionLaneId === undefined
+            ? {}
+            : { executionLaneId: requireSafeIdentity(context.executionLaneId, "ExecutionLane id") }),
+        ...(context.workspace === undefined
+            ? {}
+            : { workspace: validateManagedWorkspace(context.workspace) }),
+        effective: validateEffectiveLaunchSnapshot(context.effective),
+        status: "active",
+        createdAt: timestamp,
+        updatedAt: timestamp
+    };
+}
+export function isActiveTurn(run) {
+    return run.status === "active";
+}
+/** Binds a freshly created, not-yet-persisted Turn to its frozen Context. */
+export function withTurnContextSnapshot(run, snapshot, deltaRefIds = []) {
+    const initial = run.inputs[0];
+    if (run.status !== "active" || initial.input.contextSnapshotRef !== undefined) {
+        throw new Error(`Cannot replace the Turn Context Snapshot: ${run.id}.`);
+    }
+    const input = createTurnInput({
+        ...initial.input,
+        contextSnapshotRef: snapshot,
+        deltaRefIds
+    });
+    return validateTurn(Object.freeze({
+        ...run,
+        inputs: [turnInputRecord(input, 1, initial.submittedAt), ...run.inputs.slice(1)]
+    }));
+}
+export function appendTurnInput(run, input, now) {
+    validateTurn(run);
+    if (run.status !== "active")
+        throw new Error(`Cannot append input to terminal Turn: ${run.id}.`);
+    const timestamp = now.toISOString();
+    if (Date.parse(timestamp) < Date.parse(run.updatedAt)) {
+        throw new Error("Turn input timestamp moved backwards.");
+    }
+    return validateTurn({
+        ...run,
+        inputs: [...run.inputs, turnInputRecord(input, run.inputs.length + 1, timestamp)],
+        updatedAt: timestamp
+    });
+}
+/** Derives Provider-visible identity from the Turn, the sole semantic owner. */
+export function turnInputEnvelope(run, sequence = 1) {
+    validateTurn(run);
+    const record = run.inputs[sequence - 1];
+    if (record === undefined)
+        throw new Error(`Turn input does not exist: ${run.id}/${sequence}.`);
+    return createTurnInputEnvelope(turnEnvelopeContext(run), record.input);
+}
+export function validateTurn(run) {
+    rejectUnknownFields(run, [
+        "schemaVersion",
+        "id",
+        "taskId",
+        "roleName",
+        "mode",
+        "inputs",
+        "purpose",
+        "workItemId",
+        "reviewRoundId",
+        "executionGroupId",
+        "executionLaneId",
+        "workspace",
+        "effective",
+        "status",
+        "result",
+        "createdAt",
+        "updatedAt"
+    ], "Turn");
+    if (run.schemaVersion !== 1)
+        throw new Error("Turn must use schemaVersion 1.");
+    validateTaskRecordReference({ taskId: run.taskId, localId: run.id }, "turn");
+    requireSafeIdentity(run.roleName, "Role name");
+    if (run.mode !== "new" && run.mode !== "resume") {
+        throw new Error(`Turn dispatch mode is invalid: ${String(run.mode)}.`);
+    }
+    if (!Array.isArray(run.inputs) || run.inputs.length === 0) {
+        throw new Error("Turn requires at least one input.");
+    }
+    for (const [index, record] of run.inputs.entries()) {
+        if (record.sequence !== index + 1)
+            throw new Error("Turn input sequence is invalid.");
+        requireTimestamp(record.submittedAt, "Turn input submittedAt");
+        validateTurnInput(record.input);
+        if (index > 0 && Date.parse(record.submittedAt) < Date.parse(run.inputs[index - 1].submittedAt)) {
+            throw new Error("Turn input timestamps moved backwards.");
+        }
+    }
+    if (!["execution", "review"].includes(run.purpose)) {
+        throw new Error(`Turn purpose is invalid: ${String(run.purpose)}.`);
+    }
+    if (run.workItemId !== undefined) {
+        validateTaskRecordReference({ taskId: run.taskId, localId: run.workItemId }, "workItem");
+    }
+    if (run.reviewRoundId !== undefined) {
+        validateTaskRecordReference({ taskId: run.taskId, localId: run.reviewRoundId }, "reviewRound");
+    }
+    if ((run.executionGroupId === undefined) !== (run.executionLaneId === undefined)) {
+        throw new Error("Turn execution lineage is incomplete.");
+    }
+    if (run.executionGroupId !== undefined) {
+        requireSafeIdentity(run.executionGroupId, "ExecutionGroup id");
+        requireSafeIdentity(run.executionLaneId, "ExecutionLane id");
+    }
+    if (run.workspace !== undefined) {
+        validateManagedWorkspace(run.workspace);
+        if (run.workspace.owner.taskId !== run.taskId) {
+            throw new Error("Turn workspace belongs to another Task.");
+        }
+        if (run.workspace.owner.type === "work-item"
+            && run.workspace.owner.workItemId !== run.workItemId) {
+            throw new Error("Turn workspace belongs to another Work Item.");
+        }
+        if (run.workspace.owner.type === "work-item" && run.workItemId === undefined) {
+            throw new Error("A WorkItem workspace requires a WorkItem Turn reference.");
+        }
+        if (run.workspace.owner.type === "review-round" && run.purpose !== "review") {
+            throw new Error("A ReviewRound workspace requires a review Turn.");
+        }
+        if (run.workspace.owner.type === "integration-attempt") {
+            throw new Error("An IntegrationAttempt workspace cannot be used by a Turn.");
+        }
+        if (run.workspace.owner.type === "execution-lane") {
+            if (run.workspace.owner.executionGroupId !== run.executionGroupId
+                || run.workspace.owner.executionLaneId !== run.executionLaneId) {
+                throw new Error("Turn Execution Lane workspace lineage does not match the Turn.");
+            }
+            if (run.workspace.owner.purpose === "execution"
+                && run.workspace.owner.workItemId !== run.workItemId) {
+                throw new Error("Turn Execution Lane workspace WorkItem does not match the Turn.");
+            }
+            if (run.workspace.owner.purpose === "review"
+                && run.workspace.owner.reviewRoundId !== run.reviewRoundId) {
+                throw new Error("Turn review Lane workspace ReviewRound does not match the Turn.");
+            }
+        }
+        if (run.workspace.owner.type === "review-round"
+            && run.workspace.owner.reviewRoundId !== run.reviewRoundId) {
+            throw new Error(`Turn ReviewRound workspace owner does not match ${run.reviewRoundId ?? "none"}.`);
+        }
+    }
+    if (run.purpose === "review") {
+        if (run.reviewRoundId === undefined) {
+            throw new Error("A review Turn requires a ReviewRound reference.");
+        }
+        if (run.workspace === undefined
+            || !((run.workspace.owner.type === "review-round"
+                && run.workspace.owner.reviewRoundId === run.reviewRoundId)
+                || (run.workspace.owner.type === "execution-lane"
+                    && run.workspace.owner.purpose === "review"
+                    && run.workspace.owner.reviewRoundId === run.reviewRoundId))) {
+            throw new Error(`A review Turn requires its exact ReviewRound workspace owner: ${run.reviewRoundId}.`);
+        }
+        if (run.workspace.entries.length === 0
+            || run.workspace.entries.some(({ access }) => access !== "write")) {
+            throw new Error("A review Turn requires only isolated writable workspace entries.");
+        }
+    }
+    else {
+        if (run.reviewRoundId !== undefined) {
+            throw new Error("An execution Turn cannot reference a ReviewRound.");
+        }
+        if (run.workspace?.owner.type === "review-round") {
+            throw new Error("An execution Turn cannot use a ReviewRound-owned workspace.");
+        }
+        if (run.workspace?.owner.type === "execution-lane" && run.workspace.owner.purpose !== "execution") {
+            throw new Error("An execution Turn cannot use a review Lane workspace.");
+        }
+    }
+    validateEffectiveLaunchSnapshot(run.effective);
+    if (run.workspace !== undefined
+        && (run.effective.workspace.root !== run.workspace.root
+            || JSON.stringify(run.effective.workspace.entries) !== JSON.stringify(run.workspace.entries))) {
+        throw new Error("Turn effective workspace does not match its managed workspace.");
+    }
+    if (run.purpose === "review") {
+        if (run.effective.reviewRoundId !== run.reviewRoundId) {
+            throw new Error("Review Turn effective provenance does not match its ReviewRound.");
+        }
+        if (!run.workspace.entries.some(({ baseCommit }) => baseCommit === run.effective.reviewBaseCommit)) {
+            throw new Error("Review Turn effective base does not match its workspace.");
+        }
+    }
+    else if (run.effective.reviewRoundId !== undefined) {
+        throw new Error("Execution Turn cannot carry Review effective provenance.");
+    }
+    for (const record of run.inputs) {
+        createTurnInputEnvelope(turnEnvelopeContext(run), record.input);
+    }
+    if (!["active", "completed", "failed"].includes(run.status)) {
+        throw new Error(`Turn status is invalid: ${String(run.status)}.`);
+    }
+    requireTimestamp(run.createdAt, "Turn createdAt");
+    requireTimestamp(run.updatedAt, "Turn updatedAt");
+    if (run.status === "active") {
+        if (run.result !== undefined)
+            throw new Error("An active Turn cannot have a result.");
+    }
+    else {
+        const result = validateTurnResult(run.result);
+        if (run.status === "failed") {
+            if (!isTurnFailureReason(result.failureReason)) {
+                throw new Error(`Failed Turn reason is invalid: ${String(result.failureReason)}.`);
+            }
+        }
+        else if (result.failureReason !== undefined) {
+            throw new Error("A completed Turn cannot carry a failure reason.");
+        }
+    }
+    return run;
+}
+export function completeTurn(run, output, now, provider) {
+    return finishTurn(run, "completed", output, now, undefined, provider);
+}
+export function failTurn(run, reason, output, now, provider) {
+    return finishTurn(run, "failed", output, now, reason, provider);
+}
+function finishTurn(run, status, output, now, failureReason, provider) {
+    if (run.status !== "active") {
+        throw new Error(`Turn is already terminal: ${run.id}.`);
+    }
+    const timestamp = now.toISOString();
+    const terminal = {
+        ...run,
+        status,
+        result: {
+            schemaVersion: 1,
+            output: requireResultText(output, "Turn result output"),
+            completedAt: timestamp,
+            ...(provider === undefined ? {} : { provider: validateTurnProviderResult(provider) }),
+            ...(failureReason === undefined ? {} : { failureReason })
+        },
+        updatedAt: timestamp,
+    };
+    return validateTurn(terminal);
+}
+function validateTurnResult(result) {
+    if (result === undefined || result.schemaVersion !== 1) {
+        throw new Error("A terminal Turn requires TurnResult schemaVersion 1.");
+    }
+    requireResultText(result.output, "Turn result output");
+    requireTimestamp(result.completedAt, "Turn result completedAt");
+    if (result.provider !== undefined)
+        validateTurnProviderResult(result.provider);
+    return result;
+}
+function validateTurnProviderResult(provider) {
+    requireText(provider.providerNamespace, "Provider namespace");
+    requireText(provider.accountScope, "Provider account scope");
+    requireText(provider.conversationId, "Provider Conversation id");
+    requireText(provider.activationId, "Provider Activation id");
+    requireText(provider.nativeTurnId, "Provider native Turn id");
+    if (!["completed", "failed", "cancelled"].includes(provider.status)) {
+        throw new Error(`Provider Turn result status is invalid: ${String(provider.status)}.`);
+    }
+    return provider;
+}
+function turnInputRecord(input, sequence, submittedAt) {
+    const normalized = validateTurnInput(input);
+    return Object.freeze({
+        sequence,
+        submittedAt,
+        input: normalized
+    });
+}
+function turnEnvelopeContext(run) {
+    return {
+        turnId: run.id,
+        roleName: run.roleName,
+        purpose: run.purpose,
+        subject: {
+            taskId: run.taskId,
+            ...(run.workItemId === undefined ? {} : { workItemId: run.workItemId }),
+            ...(run.reviewRoundId === undefined ? {} : { reviewRoundId: run.reviewRoundId }),
+            ...(run.executionGroupId === undefined ? {} : {
+                executionGroupId: run.executionGroupId,
+                executionLaneId: run.executionLaneId
+            })
+        }
+    };
+}
+function requireSafeIdentity(value, label) {
+    const normalized = requireText(value, label);
+    if (["__proto__", "prototype", "constructor", ".", ".."].includes(normalized)
+        || /[\/\\\0]/.test(normalized)) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return normalized;
+}
+function requireText(value, label) {
+    if (typeof value !== "string" || value.includes("\0"))
+        throw new Error(`${label} is invalid.`);
+    const normalized = value.trim();
+    if (normalized.length === 0)
+        throw new Error(`${label} is required.`);
+    return normalized;
+}
+/** Result transport preserves the provider's complete text, including outer whitespace. */
+function requireResultText(value, label) {
+    if (typeof value !== "string" || value.includes("\0"))
+        throw new Error(`${label} is invalid.`);
+    if (value.trim().length === 0)
+        throw new Error(`${label} is required.`);
+    return value;
+}
+function requireTimestamp(value, label) {
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) {
+        throw new Error(`${label} must be an ISO timestamp.`);
+    }
+}
+function isTurnFailureReason(value) {
+    return [
+        "startup-failed",
+        "runtime-failed",
+        "delivery-unknown",
+        "missing-result",
+        "cancelled"
+    ].includes(String(value));
+}
+function rejectUnknownFields(value, fields, label) {
+    const allowed = new Set(fields);
+    const unknown = Object.keys(value).find((field) => !allowed.has(field));
+    if (unknown !== undefined)
+        throw new Error(`${label} has unknown field: ${unknown}.`);
+}

package/dist/{run/runIdentity.js → turn/turnIdentity.js}

@@ -1,22 +1,22 @@
 import { MAX_SESSION_TITLE_LENGTH } from "../runtime/sessionTitle.js";
 /**
  * Prefixes managed launch input with its session title. The bootstrap body
- * exposes the exact current Run identity to the Agent, while structured
+ * exposes the exact current Turn identity to the Agent, while structured
  * delivery metadata and control hooks retain the delivery fence.
  */
 export function prefixYuiTitleInput(input, title) {
     const text = input.replace(/\r/g, "").trim();
     if (text.length === 0)
         throw new Error("Managed input body is required.");
-    return `${requireRunTitle(title)}\n\n${text}`;
+    return `${requireTurnTitle(title)}\n\n${text}`;
 }
-function requireRunTitle(value) {
+function requireTurnTitle(value) {
     const title = value.trim();
     if (title.length === 0
         || title.length > MAX_SESSION_TITLE_LENGTH
         || /[\r\n\0]/u.test(title)
         || !title.startsWith("Yui ")) {
-        throw new Error("Run title is invalid.");
+        throw new Error("Turn title is invalid.");
     }
     return title;
 }

package/dist/verification/gateArtifactStore.js

@@ -4,8 +4,8 @@ import { gateArtifactKey, isReusableGateArtifact, validateGateArtifact, verifyGa
 /**
  * Issue 08: the GateArtifact store adapter.
  *
- * Every function delegates to a {@link GateArtifactStorePort} (satisfied by
- * both SqliteTaskStore and FileTaskStore).  The artifact record and its step
+ * Every function delegates to a {@link GateArtifactStorePort}. The artifact
+ * record and its step
  * logs are persisted atomically by the store implementation; this module
  * owns the domain logic (key computation, log hashing, reuse lookup,
  * retention) but no filesystem paths.

package/dist/web/assets/client/app.js

@@ -87,7 +87,7 @@ function urlTaskId() {
   return readQuery().get("task") || null;
 }
 
-// The visible detail section is part of the URL (?task=X&section=runs) so a
+// The visible detail section is part of the URL (?task=X&section=exec) so a
 // refresh or a shared link lands on the same section. Writes always replace —
 // section moves are not history entries.
 function setSectionParam(targetId) {

package/dist/web/assets/client/components.js

@@ -114,9 +114,9 @@ export function executionBand(projection, t, locale) {
   head.append(pill(t, "exec.status", projection.status));
   head.append(node("span", "exec-band-owner",
     t("exec.owner." + projection.owner) + " · " + t("exec.action." + projection.action)));
-  if (projection.activeRuns && projection.activeRuns.length > 0) {
+  if (projection.activeTurns && projection.activeTurns.length > 0) {
     head.append(node("span", "exec-band-executors",
-      projection.activeRuns.length + " " + t("exec.executors")));
+      projection.activeTurns.length + " " + t("exec.executors")));
   }
   if (projection.monitoring === "stopped") {
     head.append(node("span", "exec-band-stopped", t("exec.monitoring.stopped")));
@@ -296,7 +296,7 @@ export function candidateList(candidates, t, locale) {
       row.append(node("span", "candidate-summary", candidate.summary));
       const source = candidate.source.type === "direct"
         ? t("candidate.source.direct")
-        : t("candidate.source.run") + " " + candidate.source.runId;
+        : t("candidate.source.turn") + " " + candidate.source.turnId;
       row.append(node("span", "candidate-source", source));
       row.append(node("time", "", formatDateTime(candidate.createdAt, locale)));
       list.append(row);
@@ -478,7 +478,7 @@ export function inputCard(input, _options, t, locale, actions) {
   }
   if (input.requester) {
     top.append(node("span", "input-requester",
-      t("detail.requester") + " · " + input.requester.roleName + " / " + input.requester.runId));
+      t("detail.requester") + " · " + input.requester.roleName + " / " + input.requester.turnId));
   }
   card.append(top);
   card.append(answerActions(input, actions, t));
@@ -611,71 +611,46 @@ export function workItemCard(item, titles, t, locale, actions, taskId) {
   return card;
 }
 
-export function runCard(run, t, locale) {
+export function turnCard(turn, t, locale) {
   const card = node("article", "execute-card");
-  card.dataset.status = run.status;
+  card.dataset.status = turn.status;
 
   const idRow = node("div", "execute-id");
-  idRow.append(statusDot(run.status));
-  idRow.append(node("span", "role", run.roleName));
-  idRow.append(node("span", "", run.id));
-  if (run.workItemId) idRow.append(node("span", "", t("detail.workItem") + " · " + run.workItemId));
-  if (run.purpose) idRow.append(chip(t("run.purpose." + run.purpose)));
-  idRow.append(node("time", "", formatDateTime(run.endedAt || run.updatedAt, locale)));
+  idRow.append(statusDot(turn.status));
+  idRow.append(node("span", "role", turn.roleName));
+  idRow.append(node("span", "", turn.id));
+  if (turn.workItemId) idRow.append(node("span", "", t("detail.workItem") + " · " + turn.workItemId));
+  if (turn.purpose) idRow.append(chip(t("turn.purpose." + turn.purpose)));
+  idRow.append(node("time", "", formatDateTime(turn.result?.completedAt || turn.updatedAt, locale)));
   card.append(idRow);
 
-  card.append(richText(t("detail.instruction"), run.assignment?.directive || run.assignment?.action || "-", t, { className: "execute-io", threshold: 320 }));
-  if (run.summary) {
-    card.append(richText(t("detail.outcome"), run.summary, t, { className: "execute-io outcome", threshold: 320 }));
+  const visibleInput = turn.inputs && turn.inputs.length ? turn.inputs[0].input : null;
+  card.append(richText(t("detail.instruction"), visibleInput?.directive || visibleInput?.action || "-", t, { className: "execute-io", threshold: 320 }));
+  if (turn.result?.output) {
+    card.append(richText(t("detail.outcome"), turn.result.output, t, { className: "execute-io outcome", threshold: 320 }));
   }
 
   const foot = node("div", "execute-foot");
   const tags = node("div", "execute-tags");
-  tags.append(chip(t("mode." + run.mode)));
-  if (run.executionGroupId) {
-    tags.append(chip(t("detail.lineage") + " · " + run.executionGroupId
-      + (run.executionLaneId ? "/" + run.executionLaneId : "")));
-  }
-  const deliveryKey = run.deliveredAt
-    ? "delivery.delivered"
-    : run.pushedAt
-      ? "delivery.pushed"
-      : "delivery.pending";
-  tags.append(chip(t(deliveryKey)));
-  const badge = run.effective ? agentBadge(run.effective) : (run.agentId ? agentBadge(run) : null);
+  tags.append(chip(t("mode." + turn.mode)));
+  if (turn.executionGroupId) {
+    tags.append(chip(t("detail.lineage") + " · " + turn.executionGroupId
+      + (turn.executionLaneId ? "/" + turn.executionLaneId : "")));
+  }
+  const badge = turn.effective ? agentBadge(turn.effective) : (turn.agentId ? agentBadge(turn) : null);
   if (badge) tags.append(badge);
   foot.append(tags);
-  foot.append(pill(t, "run", run.status));
+  foot.append(pill(t, "turn", turn.status));
   card.append(foot);
 
-  if (run.effective) {
+  if (turn.effective) {
     const eff = node("div", "record-meta");
-    eff.append(node("span", "", t("detail.effective") + " · r" + run.effective.sourceDesiredRevision));
-    eff.append(node("span", "", t("detail.profileIntent") + " · " + run.effective.profileAccess));
-    eff.append(node("span", "", t("detail.permission") + " · " + run.effective.permission.strategy));
+    eff.append(node("span", "", t("detail.effective") + " · r" + turn.effective.sourceDesiredRevision));
+    eff.append(node("span", "", t("detail.profileIntent") + " · " + turn.effective.profileAccess));
+    eff.append(node("span", "", t("detail.permission") + " · " + turn.effective.permission.strategy));
     card.append(eff);
   }
 
-  // Leader Run disposition: the machine-derived outcome of a terminal Leader
-  // Run, plus any structured wait reference.
-  if (run.disposition) {
-    const disposition = node("div", "record-meta");
-    disposition.append(node("span", "", t("run.disposition") + " · " + t("run.disposition." + run.disposition)));
-    if (run.waitReason) {
-      disposition.append(node("span", "", t("run.waitReason") + " · " + run.waitReason.kind
-        + (run.waitReason.ref ? " (" + run.waitReason.ref + ")" : "")));
-    }
-    card.append(disposition);
-  }
-
-  // Idempotent yield receipt on a yielded Run.
-  if (run.yieldReceipt) {
-    const receipt = node("div", "record-meta");
-    receipt.append(node("span", "mono", t("run.yieldReceipt") + " · " + run.yieldReceipt.receiptId));
-    receipt.append(node("time", "", formatDateTime(run.yieldReceipt.committedAt, locale)));
-    card.append(receipt);
-  }
-
   return card;
 }
 
@@ -728,7 +703,7 @@ export function roleCard(role, task, t, locale, actions) {
   headRight.append(pill(t, "role", role.status));
   const open = node("button", "record-open", "");
   open.type = "button";
-  open.append(node("span", "", t("actions.openRun")), node("span", "arrow", "→"));
+  open.append(node("span", "", t("actions.openSession")), node("span", "arrow", "→"));
   open.addEventListener("click", function () {
     if (actions.openTerminal) actions.openTerminal({ scope: "task", taskId: task.id, roleName: role.name });
   });
@@ -861,7 +836,7 @@ export function messageCard(message, t, locale) {
   const meta = node("div", "record-meta");
   meta.append(node("span", "mono", message.id));
   meta.append(node("time", "", formatDateTime(message.createdAt, locale)));
-  if (message.runId) meta.append(node("span", "mono", message.runId + (message.workItemId ? " · " + message.workItemId : "")));
+  if (message.turnId) meta.append(node("span", "mono", message.turnId + (message.workItemId ? " · " + message.workItemId : "")));
   card.append(meta);
 
   card.append(richText(null, message.body, t));