@zq-silk/yui 0.15.7 → 0.15.8

package/dist/commands/telemetryCommands.js

@@ -2,7 +2,7 @@ import { join } from "node:path";
 import { usageError } from "../errors/cliError.js";
 import { CURRENT_CONFIG_SCHEMA_VERSION } from "../storage/taskStore.js";
 import { CURRENT_DATABASE_FILENAME as COMMITTED_DATABASE_FILENAME } from "../storage/currentTaskStore.js";
-import { DEFAULT_TERMINAL_KEEP, resolveTurnCap, resolveTerminalKeep } from "../telemetry/telemetryConfig.js";
+import { DEFAULT_TERMINAL_KEEP, resolveRunCap, resolveTerminalKeep } from "../telemetry/telemetryConfig.js";
 import { resolveTelemetryEnabled } from "../config/yuiConfig.js";
 import { SqliteTelemetryStore } from "../telemetry/sqliteTelemetryStore.js";
 /** Read the durable config, falling back to defaults when no store is available. */
@@ -24,7 +24,7 @@ export async function runTelemetryCommand(args, options) {
         ? "Telemetry command is required: status, prune, or read."
         : `Unknown command: telemetry ${command}`, "yui telemetry status [--json]\n"
         + "yui telemetry prune [--task <id>] [--keep <n>] [--dry-run] [--json]\n"
-        + "yui telemetry read --task <id> [--turn <id>] [--aggregate] [--limit <n>] [--offset <n>]");
+        + "yui telemetry read --task <id> [--run <id>] [--aggregate] [--limit <n>] [--offset <n>]");
 }
 // -- status ---------------------------------------------------------------------
 function telemetryStatus(args, options) {
@@ -33,7 +33,7 @@ function telemetryStatus(args, options) {
     const telemetry = new SqliteTelemetryStore(options.home, {
         mode,
         terminalKeep: resolveTerminalKeep(storeConfig(options).telemetryTerminalKeep),
-        turnCap: resolveTurnCap(storeConfig(options).telemetryTurnCap)
+        runCap: resolveRunCap(storeConfig(options).telemetryRunCap)
     });
     try {
         const health = telemetry.health();
@@ -43,7 +43,7 @@ function telemetryStatus(args, options) {
             : store.listTasks().map((task) => ({
                 taskId: task.id,
                 rows: telemetry.count(task.id),
-                turns: telemetry.listTurnAggregates(task.id).length
+                runs: telemetry.listRunAggregates(task.id).length
             }));
         const report = {
             mode,
@@ -54,7 +54,7 @@ function telemetryStatus(args, options) {
             lastError: health.lastError,
             totalRows: health.rows,
             terminalKeep: resolveTerminalKeep(storeConfig(options).telemetryTerminalKeep),
-            turnCap: resolveTurnCap(storeConfig(options).telemetryTurnCap),
+            runCap: resolveRunCap(storeConfig(options).telemetryRunCap),
             tasks: perTask
         };
         if (options.json || flags.has("json"))
@@ -68,10 +68,10 @@ function telemetryStatus(args, options) {
             `Coalesced:       ${health.coalesced}`,
             ...(health.lastError === null ? [] : [`Last error:      ${health.lastError}`]),
             `Terminal keep:   ${report.terminalKeep}`,
-            `Turn cap:        ${report.turnCap}`
+            `AgentRun cap:        ${report.runCap}`
         ];
         for (const task of perTask) {
-            lines.push(`  ${task.taskId}: ${task.rows} rows across ${task.turns} Turn generation(s)`);
+            lines.push(`  ${task.taskId}: ${task.rows} rows across ${task.runs} AgentRun turn(s)`);
         }
         return lines.join("\n");
     }
@@ -85,12 +85,12 @@ function telemetryPrune(args, options) {
     const taskId = stringOption(args, "--task");
     const keep = integerOption(args, "--keep", DEFAULT_TERMINAL_KEEP);
     const dryRun = flags.has("dry-run");
-    const cap = resolveTurnCap(storeConfig(options).telemetryTurnCap);
+    const cap = resolveRunCap(storeConfig(options).telemetryRunCap);
     const store = requireStore(options);
     const telemetry = new SqliteTelemetryStore(options.home, {
         mode: telemetryMode(storeConfig(options)),
         terminalKeep: keep,
-        turnCap: cap
+        runCap: cap
     });
     try {
         const tasks = taskId === undefined
@@ -98,36 +98,34 @@ function telemetryPrune(args, options) {
             : [taskId];
         const report = [];
         for (const id of tasks) {
-            const terminalTurns = new Set(store.listTurns(id)
+            const terminalRuns = new Set(store.listRuns(id)
                 .filter((run) => run.status !== "active")
                 .map((run) => run.id));
-            const entry = { taskId: id, terminalPruned: 0, activeCapped: 0, generations: [] };
-            for (const aggregate of telemetry.listTurnAggregates(id)) {
-                if (terminalTurns.has(aggregate.turnId)) {
-                    const before = telemetry.count(id, aggregate.turnId);
+            const entry = { taskId: id, terminalPruned: 0, activeCapped: 0, runs: [] };
+            for (const aggregate of telemetry.listRunAggregates(id)) {
+                if (terminalRuns.has(aggregate.runId)) {
+                    const before = telemetry.count(id, aggregate.runId);
                     const deleted = dryRun
                         ? Math.max(0, before - keep)
-                        : telemetry.pruneGeneration(aggregate.taskId, aggregate.roleName, aggregate.turnId, aggregate.generation, keep);
+                        : telemetry.pruneRun(aggregate.taskId, aggregate.roleName, aggregate.runId, keep);
                     entry.terminalPruned += deleted;
-                    entry.generations.push({
-                        turnId: aggregate.turnId,
-                        generation: aggregate.generation,
+                    entry.runs.push({
+                        runId: aggregate.runId,
                         kept: Math.min(before, keep),
                         deleted
                     });
                 }
             }
-            for (const run of store.listTurns(id)) {
+            for (const run of store.listRuns(id)) {
                 if (run.status !== "active")
                     continue;
                 const before = telemetry.count(id, run.id);
                 if (before <= cap)
                     continue;
-                const deleted = dryRun ? before - cap : telemetry.capTurn(id, run.id, cap);
+                const deleted = dryRun ? before - cap : telemetry.capRun(id, run.id, cap);
                 entry.activeCapped += deleted;
-                entry.generations.push({
-                    turnId: run.id,
-                    generation: "*",
+                entry.runs.push({
+                    runId: run.id,
                     kept: Math.min(before, cap),
                     deleted
                 });
@@ -143,15 +141,15 @@ function telemetryPrune(args, options) {
             return JSON.stringify(result, null, 2);
         const lines = [
             `Telemetry prune (${dryRun ? "dry-run" : "applied"}):`,
-            `  terminal generations pruned: ${totals.terminalPruned} row(s) (keep ${keep})`,
-            `  active Turns capped:         ${totals.activeCapped} row(s) (cap ${cap})`
+            `  terminal runs pruned: ${totals.terminalPruned} row(s) (keep ${keep})`,
+            `  active AgentRuns capped:         ${totals.activeCapped} row(s) (cap ${cap})`
         ];
         for (const entry of report) {
-            if (entry.generations.length === 0)
+            if (entry.runs.length === 0)
                 continue;
             lines.push(`  ${entry.taskId}:`);
-            for (const generation of entry.generations) {
-                lines.push(`    ${generation.turnId}/${generation.generation}: kept ${generation.kept}, deleted ${generation.deleted}`);
+            for (const run of entry.runs) {
+                lines.push(`    ${run.runId}: kept ${run.kept}, deleted ${run.deleted}`);
             }
         }
         return lines.join("\n");
@@ -165,33 +163,33 @@ function telemetryRead(args, options) {
     const flags = parseFlags(args, new Set(["aggregate", "json"]));
     const taskId = stringOption(args, "--task");
     if (taskId === undefined) {
-        throw usageError("telemetry read requires --task <id>.", "yui telemetry read --task <id> [--turn <id>] [--aggregate]");
+        throw usageError("telemetry read requires --task <id>.", "yui telemetry read --task <id> [--run <id>] [--aggregate]");
     }
-    const turnId = stringOption(args, "--turn");
+    const runId = stringOption(args, "--run");
     const limit = integerOption(args, "--limit", 100);
     const offset = integerOption(args, "--offset", 0);
     const telemetry = new SqliteTelemetryStore(options.home, {
         mode: telemetryMode(storeConfig(options)),
         terminalKeep: resolveTerminalKeep(storeConfig(options).telemetryTerminalKeep),
-        turnCap: resolveTurnCap(storeConfig(options).telemetryTurnCap)
+        runCap: resolveRunCap(storeConfig(options).telemetryRunCap)
     });
     try {
         if (flags.has("aggregate")) {
-            if (turnId === undefined) {
-                const aggregates = telemetry.listTurnAggregates(taskId);
+            if (runId === undefined) {
+                const aggregates = telemetry.listRunAggregates(taskId);
                 if (options.json || flags.has("json"))
                     return JSON.stringify(aggregates, null, 2);
                 return aggregates.map((aggregate) => formatAggregate(aggregate)).join("\n") || "(no telemetry)";
             }
-            const aggregate = telemetry.aggregate(taskId, turnId);
+            const aggregate = telemetry.aggregate(taskId, runId);
             if (options.json || flags.has("json"))
                 return JSON.stringify(aggregate, null, 2);
-            return aggregate === null ? "(no telemetry for this Turn)" : formatAggregate(aggregate);
+            return aggregate === null ? "(no telemetry for this AgentRun)" : formatAggregate(aggregate);
         }
-        const page = telemetry.list(taskId, turnId, { limit, offset });
+        const page = telemetry.list(taskId, runId, { limit, offset });
         if (options.json || flags.has("json"))
             return JSON.stringify(page, null, 2);
-        const lines = page.items.map((entry) => `${entry.receivedAt} ${entry.turnId}/${entry.generation}/${entry.progressId}`
+        const lines = page.items.map((entry) => `${entry.receivedAt} ${entry.runId}/${entry.progressId}`
             + `${entry.sequence === undefined ? "" : ` seq=${entry.sequence}`}`);
         if (page.nextOffset !== null)
             lines.push(`(next offset: ${page.nextOffset})`);
@@ -240,5 +238,5 @@ function integerOption(args, name, fallback) {
     return value;
 }
 function formatAggregate(aggregate) {
-    return `${aggregate.turnId}/${aggregate.generation}: count=${aggregate.count} first=${aggregate.firstAt} last=${aggregate.lastAt} maxSequence=${aggregate.maxSequence === null ? "-" : aggregate.maxSequence} errors=${aggregate.errorCount}`;
+    return `${aggregate.runId}/: count=${aggregate.count} first=${aggregate.firstAt} last=${aggregate.lastAt} maxSequence=${aggregate.maxSequence === null ? "-" : aggregate.maxSequence} errors=${aggregate.errorCount}`;
 }

package/dist/config/configCatalog.js

@@ -1,4 +1,4 @@
-import { MAX_TURN_CAP } from "../telemetry/telemetryConfig.js";
+import { MAX_RUN_CAP } from "../telemetry/telemetryConfig.js";
 export const CONFIG_DOMAINS = ["system", "runtime", "workflow", "resources", "tools"];
 /**
  * Public durable configuration contract. CLI help, completion, config show,
@@ -15,7 +15,7 @@ export const CONFIG_DEFINITIONS = Object.freeze([
     { key: "agent-launch-inactivity-timeout-seconds", domain: "runtime", property: "agentLaunchInactivityTimeoutSeconds", label: "Agent launch inactivity timeout", summary: "Maximum launch silence before startup fails, 15-3600 seconds (default: 300).", takesEffect: "After the Controller restarts." },
     { key: "delivery-timeout-seconds", domain: "runtime", property: "deliveryTimeoutSeconds", label: "Delivery timeout", summary: "Total control-plane delivery retry budget, 5-600 seconds (default: 120).", takesEffect: "After the Controller restarts; internal retry cadence remains automatic." },
     { key: "leader-next-action", domain: "workflow", property: "leaderNextActionMode", label: "Leader next-action mode", summary: "Leader next-action mode: display, warn, or enforce (default: display).", takesEffect: "The next Leader next-action projection or gate." },
-    { key: "leader-semantic-budget-turns", domain: "workflow", property: "leaderSemanticBudgetTurns", label: "Leader semantic budget", summary: "Consecutive completed Leader turns without durable delivery progress before warning, 1-20 (default: 3).", takesEffect: "The next Leader delivery guard evaluation." },
+    { key: "leader-semantic-budget-runs", domain: "workflow", property: "leaderSemanticBudgetRuns", label: "Leader semantic budget", summary: "Consecutive completed Leader AgentRuns without durable delivery progress before warning, 1-20 (default: 3).", takesEffect: "The next Leader delivery guard evaluation." },
     { key: "review", domain: "workflow", property: "review", label: "Review", summary: "Optional global WorkItem review rule: a configured Role plus always, leader, or final trigger. Setup leaves it disabled so the Leader may review directly or delegate selectively.", takesEffect: "The next Candidate snapshot; in-flight Candidates and ReviewRounds keep their policy." },
     { key: "resources-gc-mode", domain: "resources", property: "resourcesGcMode", label: "Resources GC mode", summary: "Resource GC mode: report or quarantine (default: report).", takesEffect: "The next resource GC operation." },
     { key: "resources-gc-auto-quarantine", domain: "resources", property: "resourcesGcAutoQuarantine", label: "Resources GC auto-quarantine", summary: "Automatically quarantine eligible terminal Task resources (default: false).", takesEffect: "The next eligible automatic resource GC operation." },
@@ -23,8 +23,8 @@ export const CONFIG_DEFINITIONS = Object.freeze([
     { key: "tmux-bin", domain: "tools", property: "tmuxBin", label: "Tmux bin", summary: "Command or path to the tmux binary (default: tmux).", takesEffect: "The next CLI-owned tmux invocation; restart the Controller for Controller-owned launches." },
     { key: "tmux-history-limit", domain: "tools", property: "tmuxHistoryLimit", label: "Tmux history limit", summary: "History lines retained for newly created tmux sessions, 1000-1000000 (default: 100000).", takesEffect: "New tmux sessions; existing sessions report drift until recreated." },
     { key: "telemetry-enabled", domain: "tools", property: "telemetryEnabled", label: "Diagnostic telemetry", summary: "Enable the optional SQLite diagnostic telemetry projection (default: false); requires a SQLite Home.", takesEffect: "Standalone telemetry commands immediately; scheduler writes after Controller restart." },
-    { key: "telemetry-terminal-keep", domain: "tools", property: "telemetryTerminalKeep", label: "Telemetry terminal keep", summary: "Positive-integer rows retained per terminal Turn generation (default: 200).", takesEffect: "Explicit retention immediately; automatic retention after the Controller restarts." },
-    { key: "telemetry-turn-cap", domain: "tools", property: "telemetryTurnCap", label: "Telemetry Turn cap", summary: `Positive-integer maximum rows retained per Turn, at most ${MAX_TURN_CAP} (default: 50000).`, takesEffect: "Explicit retention immediately; automatic write-time capping after the Controller restarts." }
+    { key: "telemetry-terminal-keep", domain: "tools", property: "telemetryTerminalKeep", label: "Telemetry terminal keep", summary: "Positive-integer rows retained per terminal AgentRun (default: 200).", takesEffect: "Explicit retention immediately; automatic retention after the Controller restarts." },
+    { key: "telemetry-run-cap", domain: "tools", property: "telemetryRunCap", label: "Telemetry AgentRun cap", summary: `Positive-integer maximum rows retained per AgentRun, at most ${MAX_RUN_CAP} (default: 50000).`, takesEffect: "Explicit retention immediately; automatic write-time capping after the Controller restarts." }
 ]);
 export const CONFIG_KEYS = Object.freeze(CONFIG_DEFINITIONS.map(({ key }) => key));
 export function configDefinitionsForDomain(domain) {

package/dist/config/yuiConfig.js

@@ -1,4 +1,4 @@
-import { DEFAULT_TURN_CAP, DEFAULT_TERMINAL_KEEP, MAX_TURN_CAP } from "../telemetry/telemetryConfig.js";
+import { DEFAULT_RUN_CAP, DEFAULT_TERMINAL_KEEP, MAX_RUN_CAP } from "../telemetry/telemetryConfig.js";
 import { DEFAULT_RUNTIME_HEALTH_POLICY } from "../runtime/runtimeHealthPolicy.js";
 export const DEFAULT_RECONCILIATION_INTERVAL_SECONDS = 120;
 export const MIN_RECONCILIATION_INTERVAL_SECONDS = 5;
@@ -99,14 +99,14 @@ export function resolveTelemetryTerminalKeep(value) {
     }
     return value;
 }
-export function resolveTelemetryTurnCap(value) {
+export function resolveTelemetryRunCap(value) {
     if (value === undefined || value === null)
-        return DEFAULT_TURN_CAP;
+        return DEFAULT_RUN_CAP;
     if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
         throw new TypeError("telemetryTurnCap must be a positive integer.");
     }
-    if (value > MAX_TURN_CAP) {
-        throw new TypeError(`telemetryTurnCap must not exceed ${MAX_TURN_CAP.toLocaleString("en-US")} (retention cannot be disabled).`);
+    if (value > MAX_RUN_CAP) {
+        throw new TypeError(`telemetryTurnCap must not exceed ${MAX_RUN_CAP.toLocaleString("en-US")} (retention cannot be disabled).`);
     }
     return value;
 }
@@ -115,7 +115,7 @@ export const DEFAULT_CONTROLLER_TASK_CONCURRENCY = 4;
 export const MAX_CONTROLLER_TASK_CONCURRENCY = 32;
 export const DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS = 300;
 export const DEFAULT_DELIVERY_TIMEOUT_SECONDS = 120;
-export const DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS = 3;
+export const DEFAULT_LEADER_SEMANTIC_BUDGET_RUNS = 3;
 export const DEFAULT_TMUX_HISTORY_LIMIT = 100_000;
 export function resolveRuntimeHealth(configured) {
     if (configured === undefined || configured === null)
@@ -141,8 +141,8 @@ export function resolveAgentLaunchInactivityTimeoutSeconds(value) {
 export function resolveDeliveryTimeoutSeconds(value) {
     return resolveBoundedPositiveInteger(value, DEFAULT_DELIVERY_TIMEOUT_SECONDS, 5, 600, "deliveryTimeoutSeconds");
 }
-export function resolveLeaderSemanticBudgetTurns(value) {
-    return resolveBoundedPositiveInteger(value, DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS, 1, 20, "leaderSemanticBudgetTurns");
+export function resolveLeaderSemanticBudgetRuns(value) {
+    return resolveBoundedPositiveInteger(value, DEFAULT_LEADER_SEMANTIC_BUDGET_RUNS, 1, 20, "leaderSemanticBudgetRuns");
 }
 export function resolveTmuxHistoryLimit(value) {
     return resolveBoundedPositiveInteger(value, DEFAULT_TMUX_HISTORY_LIMIT, 1_000, 1_000_000, "tmuxHistoryLimit");

package/dist/context/contextSnapshot.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { normalizedUniqueText, optionalText, requireIdentity, requirePositiveInteger, requireText, requireTimestamp } from "../domain/validation.js";
-import { MAX_CONTEXT_SOURCE_TURN_BYTES, MAX_CONTEXT_SOURCE_TURNS } from "./sourceTurnContext.js";
+import { MAX_CONTEXT_SOURCE_RUN_BYTES, MAX_CONTEXT_SOURCE_RUNS } from "./sourceRunContext.js";
 export const CONTEXT_SNAPSHOT_SCHEMA_VERSION = 1;
 export const CONTEXT_SNAPSHOT_MAX_RESOURCES = 256;
 export const CONTEXT_SNAPSHOT_MAX_RESOURCE_BYTES = 4 * 1024 * 1024;
@@ -185,16 +185,16 @@ function validateContextRef(value) {
 function normalizeSnapshotResources(values, refs) {
     if (!Array.isArray(values))
         throw new Error("Context Snapshot resources must be an array.");
-    const sourceTurnCount = values.filter((resource) => (resource !== null
+    const sourceRunCount = values.filter((resource) => (resource !== null
         && typeof resource === "object"
         && !Array.isArray(resource)
         && resource.ref !== null
         && typeof resource.ref === "object"
-        && resource.ref.store === "source-turn")).length;
-    if (sourceTurnCount > MAX_CONTEXT_SOURCE_TURNS) {
-        throw new Error(`Context Snapshot exceeds ${MAX_CONTEXT_SOURCE_TURNS} source Turns.`);
+        && resource.ref.store === "source-run")).length;
+    if (sourceRunCount > MAX_CONTEXT_SOURCE_RUNS) {
+        throw new Error(`Context Snapshot exceeds ${MAX_CONTEXT_SOURCE_RUNS} source AgentRuns.`);
     }
-    if (values.length - sourceTurnCount > CONTEXT_SNAPSHOT_MAX_RESOURCES) {
+    if (values.length - sourceRunCount > CONTEXT_SNAPSHOT_MAX_RESOURCES) {
         throw new Error(`Context Snapshot exceeds ${CONTEXT_SNAPSHOT_MAX_RESOURCES} resources.`);
     }
     const byRef = new Map(refs.map((ref) => [contextRefKey(ref), ref]));
@@ -220,13 +220,13 @@ function normalizeSnapshotResources(values, refs) {
         || new Set(resources.map(({ ref }) => contextRefKey(ref))).size !== refs.length) {
         throw new Error("Context Snapshot resources must cover every ref exactly once.");
     }
-    const ordinary = resources.filter(({ ref }) => ref.store !== "source-turn");
-    const sourceTurns = resources.filter(({ ref }) => ref.store === "source-turn");
+    const ordinary = resources.filter(({ ref }) => ref.store !== "source-run");
+    const sourceRuns = resources.filter(({ ref }) => ref.store === "source-run");
     if (Buffer.byteLength(JSON.stringify(ordinary), "utf8") > CONTEXT_SNAPSHOT_MAX_BYTES) {
         throw new Error(`Context Snapshot resources exceed ${CONTEXT_SNAPSHOT_MAX_BYTES} bytes.`);
     }
-    if (Buffer.byteLength(JSON.stringify(sourceTurns), "utf8") > MAX_CONTEXT_SOURCE_TURN_BYTES) {
-        throw new Error(`Context Snapshot source Turns exceed ${MAX_CONTEXT_SOURCE_TURN_BYTES} bytes.`);
+    if (Buffer.byteLength(JSON.stringify(sourceRuns), "utf8") > MAX_CONTEXT_SOURCE_RUN_BYTES) {
+        throw new Error(`Context Snapshot source AgentRuns exceed ${MAX_CONTEXT_SOURCE_RUN_BYTES} bytes.`);
     }
     return Object.freeze(resources);
 }

package/dist/context/dispatchContext.js

@@ -9,28 +9,28 @@ export function buildLeaderContext(context) {
 export function buildWorkerContext(context) {
     return renderDispatchContext("worker", context);
 }
-const WORKER_TURN_COMPLETION_MARKER = "Yui Role Turn result requirement:";
-const WORKER_TURN_COMPLETION_REQUIREMENT = [
-    WORKER_TURN_COMPLETION_MARKER,
+const WORKER_RUN_COMPLETION_MARKER = "Yui Role AgentRun result requirement:";
+const WORKER_RUN_COMPLETION_REQUIREMENT = [
+    WORKER_RUN_COMPLETION_MARKER,
     "End the Provider turn with a truthful final report. Yui records that native turn result "
-        + "for the current Turn automatically; no completion command is required.",
+        + "for the current AgentRun automatically; no completion command is required.",
     "If you cannot finally determine success, failure, completeness, or the correct "
         + "disposition, do not guess, silently stop, or hide uncertainty behind a success "
         + "summary. Label the final report uncertain, incomplete, "
         + "blocked, or requiring Leader judgment.",
-    "Report the most complete truthful evidence available and, when applicable: exact Turn, "
+    "Report the most complete truthful evidence available and, when applicable: exact AgentRun, "
         + "WorkItem, and native Session identity; actions actually performed; changed paths "
         + "and commit/worktree state; checks actually run and their outcomes; provider, runtime, "
         + "or permission errors; the last confirmed lifecycle boundary; work not performed; "
         + "unresolved assumptions or decisions; residual risks; confidence; and bounded next options.",
-    "The Provider turn ending closes only this Turn. It does not imply Leader acceptance, "
-        + "WorkItem completion, ChangeSet capture, Integration, or Task completion. Review Turns "
+    "The Provider turn ending closes only this AgentRun. It does not imply Leader acceptance, "
+        + "WorkItem completion, ChangeSet capture, Integration, or Task completion. Review AgentRuns "
         + "report findings, verification gaps, and limits; the Leader decides disposition."
 ].join("\n");
-export function ensureWorkerTurnCompletionRequirement(input) {
-    return input.endsWith(`\n\n${WORKER_TURN_COMPLETION_REQUIREMENT}`)
+export function ensureWorkerRunCompletionRequirement(input) {
+    return input.endsWith(`\n\n${WORKER_RUN_COMPLETION_REQUIREMENT}`)
         ? input
-        : `${input}\n\n${WORKER_TURN_COMPLETION_REQUIREMENT}`;
+        : `${input}\n\n${WORKER_RUN_COMPLETION_REQUIREMENT}`;
 }
 function renderDispatchContext(kind, context) {
     const profile = context.role;
@@ -58,7 +58,7 @@ function renderDispatchContext(kind, context) {
     ].filter((section) => section !== null && section.length > 0)
         .join("\n\n");
     return kind === "worker"
-        ? ensureWorkerTurnCompletionRequirement(rendered)
+        ? ensureWorkerRunCompletionRequirement(rendered)
         : rendered;
 }
 function renderContextLayers(context, kind) {

package/dist/context/roleSessionContext.js

@@ -12,7 +12,7 @@ const BUILTIN_YUI_SKILLS = new Set([
 ]);
 /**
  * Compiles stable Role policy for an Agent-native instruction channel.
- * Dynamic wakeups and Turn assignments deliberately remain outside this value.
+ * Dynamic wakeups and AgentRun assignments deliberately remain outside this value.
  */
 export function compileRoleSessionContext(yuiHome, role, owner, options = {}) {
     const kind = roleSessionKind(role, owner, options.purpose ?? "execution");
@@ -48,6 +48,9 @@ export function roleSessionKind(role, owner, purpose) {
     }
     if (purpose === "review")
         return "reviewer";
+    // Planning is the same logical Leader as execution, so it deliberately
+    // resolves to the same kind and the same compatibility identity. Activation
+    // must not force a new Session just because the Task left Draft.
     return role.name === SYSTEM_LEADER_ROLE ? "leader" : "worker";
 }
 function renderRoleCore(kind, role, owner) {
@@ -66,13 +69,13 @@ function renderRoleCore(kind, role, owner) {
         case "leader":
             return [
                 `You are the Yui Leader for Task ${owner.scope === "task" ? owner.taskId : role.name}.`,
-                "Own Task stewardship and delegate bounded implementation work.",
+                "Own the Task outcome; do bounded work directly or delegate independently owned requirements when useful.",
                 "Follow the injected yui-leader Skill for Yui coordination."
             ];
         case "reviewer":
             return [
                 `You are Yui review Role ${role.name} for Task ${owner.scope === "task" ? owner.taskId : role.name}.`,
-                "Review only the exact frozen ReviewRound scope assigned to this Turn.",
+                "Review only the exact frozen ReviewRound scope assigned to this AgentRun.",
                 "Follow the injected yui-reviewer Skill while reviewing Yui work."
             ];
         case "worker":