@zq-silk/yui 0.15.7 → 0.15.8

package/dist/context/taskContext.js

@@ -0,0 +1,458 @@
+import { usageError, taskNotFound } from "../errors/cliError.js";
+import { resolveManagedTaskReader } from "../runtime/managedCaller.js";
+import { contextContentDigest } from "./contextSnapshot.js";
+import { buildRunContextPack } from "./runContextPack.js";
+import { sourceRunContextValue } from "./sourceRunContext.js";
+import { expandTaskMessageResult } from "../message/message.js";
+import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
+import { runExecutionObservation } from "../agentRun/agentRun.js";
+const MAX_RECORDS = 256;
+const MAX_VALUE_BYTES = 4096;
+const MAX_PAGE_BYTES = 128 * 1024;
+const MAX_INSPECT_BYTES = 4 * 1024 * 1024;
+const MAX_EVENTS = 100;
+const MAX_ATTENTION_REFS = 8;
+/** A current read model, not a second snapshot store or a delivery receipt.
+ * Every public path checks the same scope before reading, counting or paging.
+ */
+export function readTaskContext(store, taskId, environment = {}) {
+    return store.transaction((reader) => {
+        const entries = authorizedEntries(reader, taskId, environment);
+        const cursor = currentCursor(reader, taskId);
+        // Reserve a small, classified view before ordinary history consumes the
+        // page. Counts and samples come from the exact same authorized read.
+        const attention = summarizeAttention(entries);
+        let bytes = Buffer.byteLength(JSON.stringify(attention));
+        const records = [];
+        const runtimeEvents = entries.some((entry) => entry.ref.store === "run") ? reader.listEvents(taskId) : [];
+        for (const entry of entries) {
+            const valueBytes = Buffer.byteLength(JSON.stringify(entry.value));
+            const content = valueBytes > MAX_VALUE_BYTES
+                ? { ref: entry.ref, summary: summarize(entry.value), omitted: true }
+                : { ...entry, omitted: false };
+            const record = { ...content, ...(entry.ref.store === "run" ? {
+                    execution: runExecutionObservation(entry.value, reader.getTaskRoleSessionSet(taskId, entry.value.roleName)?.providerBinding, runtimeEvents)
+                } : {}) };
+            const size = Buffer.byteLength(JSON.stringify(record));
+            if (records.length >= MAX_RECORDS || bytes + size > MAX_PAGE_BYTES)
+                break;
+            records.push(record);
+            bytes += size;
+        }
+        return {
+            taskId, coreCursor: encode(cursor), throughCursor: encode(cursor),
+            attention,
+            records, count: entries.length,
+            omitted: { records: entries.length - records.length, values: records.filter((r) => r.omitted).length },
+            observations: [],
+            limits: { records: MAX_RECORDS, valueBytes: MAX_VALUE_BYTES, pageBytes: MAX_PAGE_BYTES,
+                attentionRefsPerCategory: MAX_ATTENTION_REFS, attentionRefBytesPerCategory: MAX_VALUE_BYTES }
+        };
+    });
+}
+function summarizeAttention(entries) {
+    const group = () => ({ count: 0, refs: [], omittedRefs: 0 });
+    const attention = {
+        openInputs: group(), pendingOperations: group(), unknownOperations: group()
+    };
+    const bytes = { openInputs: 0, pendingOperations: 0, unknownOperations: 0 };
+    for (const entry of entries) {
+        const status = entry.value.status;
+        const category = entry.ref.store === "input-request" && status === "open" ? "openInputs"
+            : entry.ref.store === "job" && status === "unknown-needs-attention" ? "unknownOperations"
+                : entry.ref.store === "job" && (status === "queued" || status === "running") ? "pendingOperations"
+                    : undefined;
+        if (category === undefined)
+            continue;
+        const summary = attention[category];
+        summary.count++;
+        const size = Buffer.byteLength(JSON.stringify(entry.ref)) + 1;
+        if (summary.refs.length < MAX_ATTENTION_REFS && bytes[category] + size <= MAX_VALUE_BYTES) {
+            summary.refs.push(entry.ref);
+            bytes[category] += size;
+        }
+        else {
+            summary.omittedRefs++;
+        }
+    }
+    return attention;
+}
+/** Delta is immutable Task event history, not latest mutable record contents
+ * mislabeled as an old snapshot. Inspect/read explicitly obtains current facts.
+ * A continuation carries the first page's fixed upper event bound.
+ */
+export function readTaskContextDelta(store, taskId, input, environment = {}) {
+    return store.transaction((reader) => {
+        const { allow } = authorizeContext(reader, taskId, environment);
+        const history = reader.listEvents(taskId);
+        const start = decode(input.after, taskId);
+        const now = currentCursor(reader, taskId, history);
+        const continuation = input.continuation === undefined ? undefined : decodePage(input.continuation, taskId);
+        const bound = continuation ?? now;
+        const after = continuation?.after ?? start.sequence;
+        if (start.sequence > bound.sequence || after < start.sequence || after > bound.sequence
+            || bound.sequence > now.sequence || start.revision > now.revision || bound.revision > now.revision) {
+            throw usageError("Context cursor is outside the current Task history.");
+        }
+        const limit = input.limit ?? MAX_EVENTS;
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_EVENTS) {
+            throw usageError(`Context delta limit must be between 1 and ${MAX_EVENTS}.`);
+        }
+        const events = history
+            .filter((event) => isAllowed(allow, "task-event", event.id)
+            && sequence(event.id) > after && sequence(event.id) <= bound.sequence)
+            .sort((a, b) => sequence(a.id) - sequence(b.id));
+        const page = [];
+        let bytes = 0;
+        for (const event of events) {
+            const entry = materialize("task-event", event.id, event);
+            const record = Buffer.byteLength(JSON.stringify(event)) > MAX_VALUE_BYTES
+                ? { ref: entry.ref, omitted: true }
+                : { ...entry, omitted: false };
+            const size = Buffer.byteLength(JSON.stringify(record));
+            if (page.length >= limit || bytes + size > MAX_PAGE_BYTES)
+                break;
+            page.push(record);
+            bytes += size;
+        }
+        const last = page.at(-1)?.ref.refId;
+        const more = events.length > page.length;
+        const through = { taskId, sequence: bound.sequence, revision: bound.revision };
+        return {
+            taskId, events: page, count: events.length, throughCursor: encode(through),
+            ...(more && last !== undefined
+                ? { continuation: encode({ ...through, after: sequence(last) }) } : {}),
+            observations: []
+        };
+    });
+}
+export function inspectTaskContext(store, taskId, selector, environment = {}) {
+    return store.transaction((reader) => {
+        const scope = authorizeContext(reader, taskId, environment);
+        const value = isAllowed(scope.allow, selector.store, selector.refId)
+            ? inspectValue(reader, scope, selector) : null;
+        if (value === null)
+            throw usageError("Context reference is unavailable in the caller's current scope.");
+        const entry = materialize(selector.store, selector.refId, value);
+        if (selector.digest !== undefined && entry.ref.digest !== selector.digest) {
+            throw usageError("Context reference changed; read its current reference before inspecting again.", undefined, {
+                currentRef: entry.ref
+            });
+        }
+        if (Buffer.byteLength(JSON.stringify(entry.value)) > MAX_INSPECT_BYTES) {
+            throw usageError("Context value exceeds the bounded inspect limit.", undefined, { ref: entry.ref, maxBytes: MAX_INSPECT_BYTES });
+        }
+        const expansion = selector.store === "task-message"
+            ? expandTaskMessageResult(value, (task, run) => reader.getRun(task, run))
+            : undefined;
+        const response = { ...entry, ...(expansion !== undefined && "result" in expansion
+                ? { result: expansion.result } : {}),
+            ...(selector.store === "run" ? { execution: runExecutionObservation(value, reader.getTaskRoleSessionSet(taskId, value.roleName)?.providerBinding, reader.listEvents(taskId)) } : {}),
+            coreCursor: encode(currentCursor(reader, taskId)) };
+        if (Buffer.byteLength(JSON.stringify(response)) > MAX_INSPECT_BYTES) {
+            throw usageError("Expanded Context exceeds the bounded inspect limit.", undefined, { ref: entry.ref, maxBytes: MAX_INSPECT_BYTES });
+        }
+        return response;
+    });
+}
+export function listContextMessages(store, taskId, environment = {}) {
+    return store.transaction((reader) => {
+        const { allow } = authorizeContext(reader, taskId, environment);
+        return reader.listMessages(taskId)
+            .filter((message) => isAllowed(allow, "task-message", message.id))
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+    });
+}
+/** Optional read-only providers receive only the caller's bounded core view.
+ * No Store, credentials or mutation port is exposed. An unavailable provider
+ * cannot prevent returning the core. This is a trusted in-process port, not a
+ * JavaScript sandbox; executable plugin admission belongs to its owner.
+ */
+export async function withContextObservations(core, providers, timeoutMs = 250) {
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 1000 || providers.length > 8) {
+        throw usageError("Optional Context providers exceed the bounded observation budget.");
+    }
+    const observations = await Promise.all(providers.map(async (provider) => {
+        const controller = new AbortController();
+        let timer;
+        try {
+            const value = await Promise.race([
+                Promise.resolve().then(() => provider.read(freeze(JSON.parse(JSON.stringify(core))), controller.signal)),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => { controller.abort(); reject(new Error("timeout")); }, timeoutMs);
+                })
+            ]);
+            if (!["known", "partial", "unknown"].includes(value.coverage)
+                || Buffer.byteLength(JSON.stringify(value)) > MAX_VALUE_BYTES)
+                throw new Error("unbounded observation");
+            return { source: provider.source.slice(0, 200), observedAt: new Date().toISOString(),
+                coverage: value.coverage, status: "available", value: JSON.parse(JSON.stringify(value.value)) };
+        }
+        catch {
+            return { source: provider.source.slice(0, 200), observedAt: new Date().toISOString(),
+                coverage: "unknown", status: "unavailable" };
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            controller.abort();
+        }
+    }));
+    return { ...core, observations };
+}
+function authorizeContext(store, taskId, environment) {
+    const caller = resolveManagedTaskReader(store, environment);
+    if (caller !== undefined && caller.taskId !== taskId)
+        throw usageError("Context is outside the caller's Task.");
+    if (caller === undefined && environment.YUI_SESSION_SCOPE === "global" && environment.YUI_ROLE !== "operator") {
+        throw usageError("Only Operator may read Task context from a global Session.");
+    }
+    if (caller === undefined && environment.YUI_SESSION_SCOPE === undefined
+        && (environment.YUI_ROLE !== undefined || environment.YUI_NATIVE_SESSION_ID !== undefined
+            || environment.YUI_TASK_ID !== undefined || environment.YUI_AGENT_ID !== undefined)) {
+        throw usageError("Incomplete managed Context caller identity.");
+    }
+    if (environment.YUI_SESSION_SCOPE !== undefined && !["task", "global"].includes(environment.YUI_SESSION_SCOPE)) {
+        throw usageError("Incomplete managed Context caller identity.");
+    }
+    const task = store.getTask(taskId);
+    if (task === null)
+        throw taskNotFound(taskId);
+    let allow;
+    if (caller !== undefined && caller.roleName !== "leader") {
+        if (caller.currentRunId === undefined)
+            throw usageError("A managed Role needs a current AgentRun to read its scoped Context.");
+        const pack = buildRunContextPack(store, taskId, caller.currentRunId);
+        allow = new Set(pack.authority.readableRefs.map((ref) => `${ref.store}:${ref.refId}`));
+        allow.add(`role:${caller.roleName}`);
+        allow.add(`turn:${caller.currentRunId}`);
+        // A frozen Assignment is not a cutoff for the Task's current user intent.
+        // Untargeted human/Operator messages are shared Task requirements; scoped
+        // messages and other Roles' results still require the Assignment's refs.
+        const sharedMessageIds = new Set(store.listMessages(taskId)
+            .filter(message => (message.kind === "user" || message.kind === "operator")
+            && message.recipient === undefined && message.workItemId === undefined
+            && message.runId === undefined)
+            .map(message => message.id));
+        for (const id of sharedMessageIds)
+            allow.add(`task-message:${id}`);
+        for (const event of store.listEvents(taskId)) {
+            if (event.type.startsWith("message.") && sharedMessageIds.has(event.payload.messageId)) {
+                allow.add(`task-event:${event.id}`);
+            }
+        }
+    }
+    return { task, allow, caller };
+}
+function isAllowed(allow, family, id) {
+    return allow === undefined || allow.has(`${family}:${id}`);
+}
+function roleProfile(role) {
+    return {
+        name: role.name, defaultAccess: role.defaultAccess, description: role.description,
+        responsibilities: role.responsibilities ?? [], constraints: role.constraints ?? [],
+        skills: role.skills ?? [], launchRevision: role.launchRevision
+    };
+}
+/** Resolve just the requested family. Families without a singular Store read
+ * use their existing list primitive, without constructing unrelated Context.
+ */
+function inspectValue(store, { task, allow, caller }, { store: family, refId }) {
+    const taskId = task.id;
+    switch (family) {
+        case "task": return refId === taskId ? task : null;
+        case "task-brief": return refId === taskId ? store.getTaskBrief(taskId) : null;
+        case "role": return store.getRole(taskId, refId);
+        case "role-profile": {
+            const role = store.getRole(taskId, refId);
+            return role === null ? null : roleProfile(role);
+        }
+        case "project-policy":
+        case "project-knowledge": {
+            const binding = task.projectBindings.find(({ projectId }) => family === "project-policy"
+                ? projectId === refId : refId.startsWith(`${projectId}:`));
+            if (binding === undefined)
+                return null;
+            const project = store.getProject(binding.projectId);
+            if (project === null)
+                return null;
+            const { knowledge, ...policy } = project;
+            if (family === "project-policy")
+                return policy;
+            const entry = knowledge.find((item) => item.status === "active" && `${project.id}:${item.id}` === refId);
+            return entry === undefined ? null : { projectId: project.id, ...entry };
+        }
+        case "input-request": return store.getInputRequest(taskId, refId);
+        case "work-item": return store.getWorkItem(taskId, refId);
+        case "accepted-work-item":
+            return allow?.has(`accepted-work-item:${refId}`) ? store.getWorkItem(taskId, refId) : null;
+        case "candidate": {
+            const parts = refId.split("/");
+            if (parts.length !== 2)
+                return null;
+            return store.getWorkItem(taskId, parts[0])?.candidates
+                .find((candidate) => candidate.id === parts[1]) ?? null;
+        }
+        case "task-message": return store.listMessages(taskId).find((message) => message.id === refId) ?? null;
+        case "run": return store.getRun(taskId, refId);
+        case "source-run": {
+            if (!allow?.has(`source-turn:${refId}`))
+                return null;
+            const run = store.getRun(taskId, refId);
+            return run === null ? null : sourceRunContextValue(run);
+        }
+        case "review-round": return store.getReviewRound(taskId, refId);
+        case "artifact": return store.getArtifact(taskId, refId);
+        case "environment-preparation": return store.getEnvironmentPreparation(taskId, refId);
+        case "change-set": return store.getChangeSet(taskId, refId);
+        case "managed-workspace": {
+            // Existing frozen AgentRun overlays use the Task/Role alias; owner keys
+            // identify the durable workspace in current Task reads.
+            if (caller?.currentRunId !== undefined && refId === `${taskId}/${caller.roleName}`) {
+                return store.getRun(taskId, caller.currentRunId)?.workspace ?? null;
+            }
+            return store.listManagedWorkspaces(taskId)
+                .find((workspace) => managedWorkspaceKey(workspace.owner) === refId) ?? null;
+        }
+        case "mailbox": {
+            if (allow !== undefined)
+                return null;
+            if (refId === "task")
+                return store.getWorkMailbox({ kind: "task", taskId });
+            const roleName = refId.startsWith("role:") ? refId.slice("role:".length) : undefined;
+            return roleName !== undefined && store.getRole(taskId, roleName) !== null
+                ? store.getWorkMailbox({ kind: "role", taskId, roleName }) : null;
+        }
+        case "task-decision": return store.getDecision(taskId, refId);
+        case "task-milestone": return store.getMilestone(taskId, refId);
+        case "job": return store.getDurableJob(taskId, refId);
+        case "publication": return store.listPublicationReferences(taskId).find((item) => item.id === refId) ?? null;
+        case "task-event": return store.listEvents(taskId).find((event) => event.id === refId) ?? null;
+        default: return null;
+    }
+}
+function authorizedEntries(store, taskId, environment) {
+    const { task, allow, caller } = authorizeContext(store, taskId, environment);
+    const entries = [];
+    const add = (family, id, value) => {
+        if (value !== null && isAllowed(allow, family, id)) {
+            entries.push(materialize(family, id, value));
+        }
+    };
+    add("task", taskId, task);
+    add("task-brief", taskId, store.getTaskBrief(taskId));
+    for (const role of store.listRoles(taskId)) {
+        add("role", role.name, role);
+        add("role-profile", role.name, roleProfile(role));
+    }
+    for (const binding of task.projectBindings) {
+        const project = store.getProject(binding.projectId);
+        if (project === null)
+            continue;
+        const { knowledge, ...policy } = project;
+        add("project-policy", project.id, policy);
+        for (const entry of knowledge.filter((k) => k.status === "active")) {
+            add("project-knowledge", `${project.id}:${entry.id}`, { projectId: project.id, ...entry });
+        }
+    }
+    // Current responsibilities and unanswered inputs precede historical bulk.
+    for (const request of store.listInputRequests(taskId).filter((r) => r.status === "open"))
+        add("input-request", request.id, request);
+    for (const item of store.listWorkItems(taskId).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))) {
+        add("work-item", item.id, item);
+        if (allow?.has(`accepted-work-item:${item.id}`))
+            add("accepted-work-item", item.id, item);
+        for (const candidate of [...item.candidates].reverse())
+            add("candidate", `${item.id}/${candidate.id}`, candidate);
+    }
+    for (const artifact of store.listArtifacts(taskId))
+        add("artifact", artifact.id, artifact);
+    for (const preparation of store.listEnvironmentPreparations(taskId))
+        add("environment-preparation", preparation.id, preparation);
+    for (const workspace of store.listManagedWorkspaces(taskId))
+        add("managed-workspace", managedWorkspaceKey(workspace.owner), workspace);
+    if (caller?.currentRunId !== undefined) {
+        add("managed-workspace", `${taskId}/${caller.roleName}`, store.getRun(taskId, caller.currentRunId)?.workspace ?? null);
+    }
+    for (const changeSet of store.listChangeSets(taskId))
+        add("change-set", changeSet.id, changeSet);
+    for (const message of store.listMessages(taskId).reverse())
+        add("task-message", message.id, message);
+    for (const run of store.listRuns(taskId).reverse()) {
+        add("run", run.id, run);
+        if (allow?.has(`source-turn:${run.id}`))
+            add("source-run", run.id, sourceRunContextValue(run));
+    }
+    for (const round of store.listReviewRounds(taskId).reverse())
+        add("review-round", round.id, round);
+    for (const request of store.listInputRequests(taskId).filter((r) => r.status !== "open"))
+        add("input-request", request.id, request);
+    if (allow === undefined) {
+        add("mailbox", "task", store.getWorkMailbox({ kind: "task", taskId }));
+        for (const role of store.listRoles(taskId)) {
+            add("mailbox", `role:${role.name}`, store.getWorkMailbox({ kind: "role", taskId, roleName: role.name }));
+        }
+    }
+    for (const decision of store.listDecisions(taskId))
+        add("task-decision", decision.id, decision);
+    for (const milestone of store.listMilestones(taskId))
+        add("task-milestone", milestone.id, milestone);
+    for (const job of store.listDurableJobs(taskId))
+        add("job", job.id, job);
+    for (const publication of store.listPublicationReferences(taskId))
+        add("publication", publication.id, publication);
+    for (const event of store.listEvents(taskId).reverse())
+        add("task-event", event.id, event);
+    return entries;
+}
+function materialize(store, refId, value) {
+    const digest = contextContentDigest(value);
+    const record = value;
+    return { ref: { store, refId, revision: String(record.revision ?? record.updatedAt ?? record.createdAt ?? digest), digest }, value };
+}
+function currentCursor(store, taskId, events = store.listEvents(taskId)) {
+    return { taskId, sequence: events.reduce((max, e) => Math.max(max, sequence(e.id)), 0), revision: store.getStateRevision() };
+}
+function sequence(id) {
+    const result = /^event-(\d+)$/.exec(id);
+    if (result === null || !Number.isSafeInteger(Number(result[1])))
+        throw usageError("Task event has an invalid sequence.");
+    return Number(result[1]);
+}
+function encode(value) {
+    return Buffer.from(JSON.stringify(value)).toString("base64url");
+}
+function decode(value, taskId) {
+    try {
+        if (value.length > 1024)
+            throw new Error("size");
+        const cursor = JSON.parse(Buffer.from(value, "base64url").toString());
+        if (cursor.taskId !== taskId || !Number.isSafeInteger(cursor.sequence) || cursor.sequence < 0
+            || !Number.isSafeInteger(cursor.revision) || cursor.revision < 0)
+            throw new Error("shape");
+        return cursor;
+    }
+    catch {
+        throw usageError("Invalid Context cursor for this Task.");
+    }
+}
+function decodePage(value, taskId) {
+    const cursor = decode(value, taskId);
+    if (!Number.isSafeInteger(cursor.after) || cursor.after < 0)
+        throw usageError("Invalid Context continuation.");
+    return cursor;
+}
+function freeze(value) {
+    if (value !== null && typeof value === "object") {
+        for (const entry of Object.values(value))
+            freeze(entry);
+        Object.freeze(value);
+    }
+    return value;
+}
+function summarize(value) {
+    const record = value;
+    return ["title", "objective", "summary", "body", "status"]
+        .flatMap((key) => typeof record[key] === "string" ? [`${key}: ${record[key]}`] : [])
+        .join("; ").slice(0, 400);
+}

package/dist/context/wakeNotification.js

@@ -10,7 +10,7 @@ import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
  * `yui task wake show <wake-id>` and the full projection with
  * `yui task context <task>`.
  *
- * The envelope is mode-agnostic: fresh generations and resumed generations
+ * The envelope is mode-agnostic: fresh Sessions and resumed Sessions
  * receive the same minimal text. The native Session is a disposable cache of
  * working context; Yui's durable Task records (including the wake ledger) are
  * the checkpoint.
@@ -29,19 +29,19 @@ export function buildTaskWakeEnvelope(reader, request) {
     const fromTime = Date.parse(request.fromCursor);
     const events = reader.listEvents(request.taskId);
     const deltaEvents = events.filter((record) => Date.parse(record.createdAt) > fromTime);
-    const turns = operationalTaskRecords(reader.listTurns(request.taskId), events, "turn");
-    const referencedTurnIds = referencedWakeTurnIds(turns, events, deltaEvents);
-    const changedTurnIds = new Set([
-        ...turns
+    const runs = operationalTaskRecords(reader.listRuns(request.taskId), events, "run");
+    const referencedRunIds = referencedWakeRunIds(runs, events, deltaEvents);
+    const changedRunIds = new Set([
+        ...runs
             .filter((record) => Date.parse(record.createdAt) > fromTime)
             .map(({ id }) => id),
-        ...referencedTurnIds
+        ...referencedRunIds
     ]);
     const counts = {
         events: deltaEvents.length,
         messages: operationalTaskRecords(reader.listMessages(request.taskId), events, "message")
             .filter((record) => Date.parse(record.createdAt) > fromTime).length,
-        turns: changedTurnIds.size
+        runs: changedRunIds.size
     };
     const activeReviews = reader.listReviewRounds(request.taskId).filter((round) => ((round.scope ?? "work-item") === "task"
         && (round.status === "pending" || round.status === "running")));
@@ -54,14 +54,14 @@ export function buildTaskWakeEnvelope(reader, request) {
             + `@${heads || round.reviewBaseCommit.slice(0, 12)}`
             + `${projects.length > 2 ? `+${projects.length - 2}` : ""}`;
     }).join(", ");
-    const render = (reasonLimit, resultTurnLimit, reviewLimit) => {
+    const render = (reasonLimit, resultRunLimit, reviewLimit) => {
         const reviewOrientation = renderReviewOrientation(reviewLimit);
         return [
             `Wake: ${request.wakeId} — delta since ${request.fromCursor}`,
             `  Reasons: ${renderReasons(request.reasons, reasonLimit)}`,
-            `  Changed: ${counts.events} events, ${counts.messages} messages, ${counts.turns} Turns`
+            `  Changed: ${counts.events} events, ${counts.messages} messages, ${counts.runs} AgentRuns`
                 + ` → yui task wake show ${request.taskId} ${request.wakeId}`,
-            `  Result Turns: ${renderResultTurns(request.taskId, referencedTurnIds, resultTurnLimit)}`,
+            `  Result AgentRuns: ${renderResultRuns(request.taskId, referencedRunIds, resultRunLimit)}`,
             `  Active Task Reviews: ${activeReviews.length === 0
                 ? "none"
                 : reviewLimit === 0
@@ -73,19 +73,19 @@ export function buildTaskWakeEnvelope(reader, request) {
         ].join("\n");
     };
     let reasonLimit = Math.min(REASON_DISPLAY_LIMIT, request.reasons.length);
-    let resultTurnLimit = Math.min(4, referencedTurnIds.length);
+    let resultRunLimit = Math.min(4, referencedRunIds.length);
     let reviewLimit = Math.min(3, activeReviews.length);
-    let body = render(reasonLimit, resultTurnLimit, reviewLimit);
+    let body = render(reasonLimit, resultRunLimit, reviewLimit);
     while (byteLength(body) + 1 > WAKE_ENVELOPE_HARD_BYTES) {
-        if (resultTurnLimit > 0)
-            resultTurnLimit -= 1;
+        if (resultRunLimit > 0)
+            resultRunLimit -= 1;
         else if (reasonLimit > 0)
             reasonLimit -= 1;
         else if (reviewLimit > 0)
             reviewLimit -= 1;
         else
             break;
-        body = render(reasonLimit, resultTurnLimit, reviewLimit);
+        body = render(reasonLimit, resultRunLimit, reviewLimit);
     }
     if (byteLength(body) + 1 > WAKE_ENVELOPE_HARD_BYTES) {
         body = fitUtf8([
@@ -99,18 +99,18 @@ export function buildTaskWakeEnvelope(reader, request) {
         taskId: request.taskId,
         wakeId: request.wakeId,
         fromCursor: request.fromCursor,
-        referencedTurnIds: Object.freeze(referencedTurnIds),
+        referencedRunIds: Object.freeze(referencedRunIds),
         totalBytes,
         text: `${body}\n`
     });
 }
-export function referencedWakeTurnIds(turns, allEvents, terminalEvents) {
-    const turnsById = new Map(operationalTaskRecords(turns, allEvents, "turn").map((turn) => [turn.id, turn]));
+export function referencedWakeRunIds(runs, allEvents, terminalEvents) {
+    const turnsById = new Map(operationalTaskRecords(runs, allEvents, "run").map((run) => [run.id, run]));
     return [...new Set(terminalEvents.flatMap((event) => {
-            if (!["turn.completed", "turn.failed", "turn.cancelled"].includes(event.type))
+            if (!["run.completed", "run.failed", "run.cancelled"].includes(event.type))
                 return [];
-            const turnId = event.payload.turnId;
-            return turnId !== undefined && turnsById.has(turnId) ? [turnId] : [];
+            const runId = event.payload.runId;
+            return runId !== undefined && turnsById.has(runId) ? [runId] : [];
         }))];
 }
 function renderReasons(reasons, limit) {
@@ -121,14 +121,14 @@ function renderReasons(reasons, limit) {
     const rendered = selected.map(renderWakeReason).join(", ");
     return elided === 0 ? rendered : `${rendered}, … (+${elided} more)`;
 }
-function renderResultTurns(taskId, turnIds, limit) {
-    if (turnIds.length === 0)
+function renderResultRuns(taskId, runIds, limit) {
+    if (runIds.length === 0)
         return "none";
     if (limit === 0)
-        return `${turnIds.length} → inspect the wake delta`;
-    return `${turnIds.slice(0, limit)
-        .map((turnId) => `${turnId} → yui task turn show ${taskId}/${turnId}`)
-        .join(", ")}${turnIds.length > limit ? `, … (+${turnIds.length - limit})` : ""}`;
+        return `${runIds.length} → inspect the wake delta`;
+    return `${runIds.slice(0, limit)
+        .map((runId) => `${runId} → yui task run show ${taskId}/${runId}`)
+        .join(", ")}${runIds.length > limit ? `, … (+${runIds.length - limit})` : ""}`;
 }
 function fitUtf8(value, maxBytes) {
     let fitted = "";