@zq-silk/yui 0.13.10 → 0.14.0

package/dist/commands/configCommands.js

@@ -1,7 +1,7 @@
 import { mkdirSync, realpathSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 import { usageError } from "../errors/cliError.js";
-import { DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS, DEFAULT_CONTROLLER_TASK_CONCURRENCY, DEFAULT_DELIVERY_TIMEOUT_SECONDS, DEFAULT_LEADER_NEXT_ACTION_MODE, DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS, DEFAULT_RECONCILIATION_INTERVAL_SECONDS, DEFAULT_RESOURCES_GC_MODE, DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS, DEFAULT_TMUX_HISTORY_LIMIT, LEADER_NEXT_ACTION_MODES, reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveContextBudget, resolveDeliveryTimeoutSeconds, resolveLeaderNextActionMode, resolveLeaderSemanticBudgetTurns, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours, resolveRuntimeHealth, resolveTelemetryEnabled, resolveTelemetryRunCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
+import { DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS, DEFAULT_CONTROLLER_TASK_CONCURRENCY, DEFAULT_DELIVERY_TIMEOUT_SECONDS, DEFAULT_LEADER_NEXT_ACTION_MODE, DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS, DEFAULT_RECONCILIATION_INTERVAL_SECONDS, DEFAULT_RESOURCES_GC_MODE, DEFAULT_RESOURCES_QUARANTINE_TTL_HOURS, DEFAULT_TMUX_HISTORY_LIMIT, LEADER_NEXT_ACTION_MODES, reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveDeliveryTimeoutSeconds, resolveLeaderNextActionMode, resolveLeaderSemanticBudgetTurns, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours, resolveRuntimeHealth, resolveTelemetryEnabled, resolveTelemetryTurnCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
 import { CONFIG_DEFINITIONS, CONFIG_KEYS, configDefinition, configDefinitionsForDomain } from "../config/configCatalog.js";
 import { resolveTimeZone } from "../output/timePresentation.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
@@ -21,7 +21,6 @@ const RECONCILIATION_SET_USAGE = "Runtime config set usage: yui config runtime s
 const RESOURCES_GC_MODE_SET_USAGE = "Resources config set usage: yui config resources set resources-gc-mode <report|quarantine>.";
 const RESOURCES_GC_AUTO_QUARANTINE_SET_USAGE = "Resources config set usage: yui config resources set resources-gc-auto-quarantine <true|false>.";
 const LEADER_NEXT_ACTION_SET_USAGE = `Workflow config set usage: yui config workflow set leader-next-action <${LEADER_NEXT_ACTION_MODES.join("|")}>.`;
-const CONTEXT_BUDGET_SET_USAGE = "Workflow config set usage: yui config workflow set context-budget [--soft-tokens <n>] [--hard-tokens <n>].";
 const REVIEW_SET_USAGE = "Workflow config set usage: yui config workflow set review --role <global-role> --trigger <always|leader|final> "
     + "[--finding-ledger <shadow|enforce>].";
 export function runConfigCommand(domain, args, store) {
@@ -57,7 +56,6 @@ function renderConfigShow(domain, config) {
 }
 /** Effective values for every user-configurable system field. */
 export function effectiveConfigData(config, domain) {
-    const budget = resolveContextBudget(config.contextBudget);
     const health = resolveRuntimeHealth(config.runtimeHealth);
     const all = {
         schemaVersion: config.schemaVersion,
@@ -69,7 +67,6 @@ export function effectiveConfigData(config, domain) {
         reconciliationIntervalSeconds: config.reconciliationIntervalSeconds
             ?? DEFAULT_RECONCILIATION_INTERVAL_SECONDS,
         leaderNextActionMode: resolveLeaderNextActionMode(config.leaderNextActionMode),
-        contextBudget: { softTokens: budget.softTokens, hardTokens: budget.hardTokens },
         resourcesGcMode: resolveResourcesGcMode(config.resourcesGcMode),
         resourcesGcAutoQuarantine: resolveResourcesGcAutoQuarantine(config.resourcesGcAutoQuarantine),
         resourcesQuarantineTtlHours: resolveResourcesQuarantineTtlHours(config.resourcesQuarantineTtlHours),
@@ -86,7 +83,7 @@ export function effectiveConfigData(config, domain) {
         tmuxHistoryLimit: resolveTmuxHistoryLimit(config.tmuxHistoryLimit),
         telemetryEnabled: resolveTelemetryEnabled(config.telemetryEnabled),
         telemetryTerminalKeep: resolveTelemetryTerminalKeep(config.telemetryTerminalKeep),
-        telemetryRunCap: resolveTelemetryRunCap(config.telemetryRunCap),
+        telemetryTurnCap: resolveTelemetryTurnCap(config.telemetryTurnCap),
         review: config.review === undefined
             ? null
             : {
@@ -151,12 +148,6 @@ function validatedConfigValue(validate, usage) {
         throw error;
     }
 }
-function parseBudgetToken(value, label) {
-    if (!/^\d+$/.test(value)) {
-        throw usageError(`${label} must be a positive integer.`);
-    }
-    return Number(value);
-}
 function parseReconciliationIntervalSeconds(value) {
     if (!/^\d+$/.test(value))
         return Number.NaN;
@@ -293,48 +284,6 @@ const CONFIG_KEY_HANDLERS = [
             return `Leader semantic budget reset to ${DEFAULT_LEADER_SEMANTIC_BUDGET_TURNS} turns\n`;
         }
     },
-    {
-        key: "context-budget",
-        showLabel: "Legacy context budget (inactive)",
-        showValue: (config) => {
-            const budget = resolveContextBudget(config.contextBudget);
-            return `inactive; legacy soft ${budget.softTokens} / hard ${budget.hardTokens} tokens`;
-        },
-        set(args, store) {
-            if (args.length !== 2 && args.length !== 4)
-                throw usageError(CONTEXT_BUDGET_SET_USAGE);
-            const options = new Map();
-            for (let index = 0; index < args.length; index += 2) {
-                const name = args[index];
-                const value = args[index + 1];
-                if (!["--soft-tokens", "--hard-tokens"].includes(name)
-                    || value === undefined
-                    || options.has(name)) {
-                    throw usageError(CONTEXT_BUDGET_SET_USAGE);
-                }
-                options.set(name, value);
-            }
-            const current = resolveContextBudget(store.getConfig().contextBudget);
-            const next = {
-                ...(options.get("--soft-tokens") === undefined
-                    ? {}
-                    : { softTokens: parseBudgetToken(options.get("--soft-tokens"), "--soft-tokens") }),
-                ...(options.get("--hard-tokens") === undefined
-                    ? {}
-                    : { hardTokens: parseBudgetToken(options.get("--hard-tokens"), "--hard-tokens") })
-            };
-            const resolved = resolveContextBudget({ ...current, ...next });
-            saveConfigKey(store, (config) => ({ ...config, contextBudget: resolved }));
-            return `Legacy context budget stored as soft ${resolved.softTokens} / hard ${resolved.hardTokens} tokens (inactive)\n`;
-        },
-        clear(store) {
-            saveConfigKey(store, (config) => {
-                const { contextBudget: _removed, ...rest } = config;
-                return rest;
-            });
-            return "Legacy context budget cleared; Session Token metrics remain read-only\n";
-        }
-    },
     {
         key: "resources-gc-mode",
         showLabel: "Resources GC mode",
@@ -573,22 +522,22 @@ const CONFIG_KEY_HANDLERS = [
         }
     },
     {
-        key: "telemetry-run-cap",
-        showLabel: "Telemetry run cap",
-        showValue: (config) => String(resolveTelemetryRunCap(config.telemetryRunCap)),
+        key: "telemetry-turn-cap",
+        showLabel: "Telemetry Turn cap",
+        showValue: (config) => String(resolveTelemetryTurnCap(config.telemetryTurnCap)),
         set(args, store) {
             if (args.length !== 1)
-                throw usageError("Tools config set usage: yui config tools set telemetry-run-cap <n>.");
-            const telemetryRunCap = validatedConfigValue(() => resolveTelemetryRunCap(Number(args[0])), "Tools config set usage: yui config tools set telemetry-run-cap <n>.");
-            saveConfigKey(store, (config) => ({ ...config, telemetryRunCap }));
-            return `Telemetry run cap set to ${telemetryRunCap}\n`;
+                throw usageError("Tools config set usage: yui config tools set telemetry-turn-cap <n>.");
+            const telemetryTurnCap = validatedConfigValue(() => resolveTelemetryTurnCap(Number(args[0])), "Tools config set usage: yui config tools set telemetry-turn-cap <n>.");
+            saveConfigKey(store, (config) => ({ ...config, telemetryTurnCap }));
+            return `Telemetry Turn cap set to ${telemetryTurnCap}\n`;
         },
         clear(store) {
             saveConfigKey(store, (config) => {
-                const { telemetryRunCap: _removed, ...rest } = config;
+                const { telemetryTurnCap: _removed, ...rest } = config;
                 return rest;
             });
-            return "Telemetry run cap reset to default\n";
+            return "Telemetry Turn cap reset to default\n";
         }
     },
     {

package/dist/commands/executionAuditCommands.js

@@ -92,36 +92,36 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     else {
         lines.push("", ...sectionError("tasks", report));
     }
-    if (report.runs.status === "ok" && report.runs.data !== undefined) {
-        const runs = report.runs.data;
-        lines.push("", `Agent runs: ${runs.total} total · ${runs.failed} failed (${(runs.failureRate * 100).toFixed(1)}%) · ${runs.yielded} yielded · ${runs.active} active`, `Duration: ${formatDuration(runs.cumulativeDurationMs)} total · ${formatDuration(runs.failedDurationMs)} in failed runs`, `By role: ${runs.byRole.leader} leader · ${runs.byRole.reviewer} reviewer · ${runs.byRole.implementer} implementer/worker · ${runs.byRole.other} other`, `By purpose: ${runs.byPurpose.execution} execution · ${runs.byPurpose.review} review`);
-        const faultRows = Object.entries(runs.faultClasses)
+    if (report.turns.status === "ok" && report.turns.data !== undefined) {
+        const turns = report.turns.data;
+        lines.push("", `Turns: ${turns.total} total · ${turns.failed} failed (${(turns.failureRate * 100).toFixed(1)}%) · ${turns.completed} completed · ${turns.active} active`, `Duration: ${formatDuration(turns.cumulativeDurationMs)} total · ${formatDuration(turns.failedDurationMs)} in failed Turns`, `By role: ${turns.byRole.leader} leader · ${turns.byRole.reviewer} reviewer · ${turns.byRole.implementer} implementer/worker · ${turns.byRole.other} other`, `By purpose: ${turns.byPurpose.execution} execution · ${turns.byPurpose.review} review`);
+        const faultRows = Object.entries(turns.faultClasses)
             .filter(([, count]) => count > 0)
             .sort((left, right) => right[1] - left[1]);
         if (faultRows.length > 0) {
-            lines.push(renderTable("Run failure classes", [
+            lines.push(renderTable("Turn failure classes", [
                 { header: "Class", minWidth: 24, maxWidth: 40 },
                 { header: "Count", minWidth: 5, maxWidth: 8 }
             ], faultRows.map(([name, count]) => [name, String(count)]), width));
         }
-        if (runs.launchFailures.total > 0) {
-            const phaseRows = Object.entries(runs.launchFailures.byPhase)
+        if (turns.launchFailures.total > 0) {
+            const phaseRows = Object.entries(turns.launchFailures.byPhase)
                 .filter(([, count]) => count > 0)
                 .sort((left, right) => right[1] - left[1]);
-            const kindRows = Object.entries(runs.launchFailures.byKind)
+            const kindRows = Object.entries(turns.launchFailures.byKind)
                 .filter(([, count]) => count > 0)
                 .sort((left, right) => right[1] - left[1]);
-            lines.push("", `Launch failures: ${runs.launchFailures.total}`, `By phase: ${phaseRows.map(([name, count]) => `${name}=${count}`).join(" · ")}`, `By kind: ${kindRows.map(([name, count]) => `${name}=${count}`).join(" · ")}`);
+            lines.push("", `Launch failures: ${turns.launchFailures.total}`, `By phase: ${phaseRows.map(([name, count]) => `${name}=${count}`).join(" · ")}`, `By kind: ${kindRows.map(([name, count]) => `${name}=${count}`).join(" · ")}`);
         }
     }
     else {
-        lines.push("", ...sectionError("runs", report));
+        lines.push("", ...sectionError("turns", report));
     }
     if (report.wakes.status === "ok" && report.wakes.data !== undefined) {
         const wakes = report.wakes.data;
-        lines.push("", `Leader wakes: ${wakes.leaderRuns} runs · ${wakes.withWakeReasons} with reasons · ${wakes.orphanWakes} orphan wakes (${wakes.orphanYieldOnly} yield-only)`);
+        lines.push("", `Leader wakes: ${wakes.leaderTurns} Turns · ${wakes.withWakeReasons} with reasons`);
         if (wakes.suppressedWakes.status === "ok") {
-            lines.push(`Suppressed wakes: ${wakes.suppressedWakes.data ?? 0} (scheduler single-flight, not failed Runs)`);
+            lines.push(`Suppressed wakes: ${wakes.suppressedWakes.data ?? 0} (scheduler single-flight, not failed Turns)`);
         }
         else if (wakes.suppressedWakes.status === "unsupported") {
             lines.push("Suppressed wakes: unsupported (no quiescence producer in this build)");
@@ -140,10 +140,10 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     if (report.sessions.status === "ok" && report.sessions.data !== undefined) {
         const sessions = report.sessions.data;
         lines.push("", `Sessions: ${sessions.generations} generations · ${sessions.broken} broken · ${sessions.stopped} stopped · ${sessions.other} other`, `Resets: ${sessions.resets} · Historical conversation switches ${sessions.conversationSwitches}`
-            + ` · lifecycle events ${sessions.lifecycleEvents} · stop failures ${sessions.stopFailures}`, `Terminal by Run relation: ${sessions.terminalByRunRelation.postRunYielded} post-run-yielded`
-            + ` · ${sessions.terminalByRunRelation.runFailed} run-failed`
-            + ` · ${sessions.terminalByRunRelation.activeRun} active-run`
-            + ` · ${sessions.terminalByRunRelation.noRun} no-run`);
+            + ` · lifecycle events ${sessions.lifecycleEvents} · stop failures ${sessions.stopFailures}`, `Terminal by Turn relation: ${sessions.terminalByTurnRelation.postTurnCompleted} post-turn-completed`
+            + ` · ${sessions.terminalByTurnRelation.turnFailed} turn-failed`
+            + ` · ${sessions.terminalByTurnRelation.activeTurn} active-turn`
+            + ` · ${sessions.terminalByTurnRelation.noTurn} no-turn`);
     }
     else {
         lines.push("", ...sectionError("sessions", report));
@@ -190,14 +190,14 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
                 .map(([category, count]) => `${category}:${count}`).join(", ")}`);
             lines.push(renderTable("Agent errors", [
                 { header: "Task", minWidth: 8, maxWidth: 14 },
-                { header: "Run", minWidth: 14, maxWidth: 24 },
+                { header: "Turn", minWidth: 14, maxWidth: 24 },
                 { header: "Role", minWidth: 8, maxWidth: 12 },
                 { header: "Category", minWidth: 12, maxWidth: 20 },
                 { header: "Code", minWidth: 16, maxWidth: 32 },
                 { header: "Session", minWidth: 12, maxWidth: 16 }
             ], errors.entries.map((entry) => [
                 entry.taskId,
-                entry.runId,
+                entry.turnId,
                 entry.roleName,
                 entry.category,
                 entry.code,
@@ -222,7 +222,7 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
             lines.push(renderTable("Task orchestration metrics", [
                 { header: "Task", minWidth: 7, maxWidth: 14 },
                 { header: "Type", minWidth: 8, maxWidth: 12 },
-                { header: "Runs", minWidth: 4, maxWidth: 6 },
+                { header: "Turns", minWidth: 4, maxWidth: 6 },
                 { header: "WIs", minWidth: 3, maxWidth: 5 },
                 { header: "Review F/D/N", minWidth: 12, maxWidth: 16 },
                 { header: "Integration A/F/R", minWidth: 17, maxWidth: 20 },
@@ -232,7 +232,7 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
             ], orchestration.tasks.map((task) => [
                 task.taskId,
                 task.taskType ?? "unspecified",
-                String(task.runs.total),
+                String(task.turns.total),
                 String(task.workItems),
                 `${task.reviews.full}/${task.reviews.delta}/${task.reviews.nonSemantic}`,
                 `${task.integrations.attempts}/${task.integrations.failed}/${task.integrations.repeatedIdentities}`,
@@ -275,15 +275,15 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     if (report.topLongRunning.status === "ok" && report.topLongRunning.data !== undefined) {
         const entries = report.topLongRunning.data;
         if (entries.length > 0) {
-            lines.push("", renderTable("Top long-running runs", [
+            lines.push("", renderTable("Top long-running Turns", [
                 { header: "Task", minWidth: 8, maxWidth: 14 },
-                { header: "Run", minWidth: 14, maxWidth: 24 },
+                { header: "Turn", minWidth: 14, maxWidth: 24 },
                 { header: "Role", minWidth: 10, maxWidth: 20 },
                 { header: "Status", minWidth: 8, maxWidth: 10 },
                 { header: "Duration", minWidth: 8, maxWidth: 10 }
             ], entries.map((entry) => [
                 entry.taskId,
-                entry.runId,
+                entry.turnId,
                 entry.roleName,
                 entry.status,
                 formatDuration(entry.durationMs)

package/dist/commands/globalRoleCommands.js

@@ -80,12 +80,7 @@ function roleContext(args, store, options) {
                 : ["perform-global-role-request"]
         },
         sessionManifestPath: environment.YUI_SESSION_MANIFEST,
-        cliCommand: "yui",
-        // Compatibility hint for already-running Sessions. New instructions use
-        // the stable command name and do not bind behavior to this wrapper path.
-        ...(environment.YUI_SESSION_CLI === undefined
-            ? {}
-            : { legacySessionCliPath: environment.YUI_SESSION_CLI })
+        cliCommand: "yui"
     });
     if (options.jsonOutput === true)
         return `${JSON.stringify(context)}\n`;
@@ -245,7 +240,7 @@ function bindRole(args, store) {
         const activeSession = existingSet?.sessions[existingSet.activeAgentId];
         try {
             const switched = switchActiveRoleAgent(withBinding, existingSet ?? createRoleSessionSet({ scope: "global", roleName: name }, role.activeAgentId, now), agentId, {
-                activeRun: false,
+                activeTurn: false,
                 nativeProcessRunning: activeSession !== undefined
                     && activeSession.status === "active"
             }, now);

package/dist/commands/jobCommands.js

@@ -4,10 +4,7 @@ import { formatTimestamp } from "../output/timePresentation.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
 const WAKEUP_PREFIX = "leader-wakeup:";
 const RECOVERY_PREFIX = "leader-recovery:";
-/**
- * A compatibility view over the two durable scheduler records. This does not
- * reintroduce the deleted generic Job queue.
- */
+/** Operational view over the two durable scheduler recovery records. */
 export function runJobCommand(args, store, options = {}) {
     const [command, ...rest] = args;
     if (command === "list")

package/dist/commands/projectCommands.js

@@ -555,7 +555,7 @@ function assertNoActiveTaskBinding(store, project, action) {
     if (references.activeTaskIds.length > 0) {
         const delivery = [
             ...references.unresolvedWorkItemRefs,
-            ...references.activeRunRefs,
+            ...references.activeTurnRefs,
             ...references.unresolvedIntegrationRefs
         ];
         throw usageError(`Project cannot be ${action} while an active Task binds it: ${project.id}. `
@@ -846,7 +846,7 @@ async function replaceProject(args, store, options) {
 }
 /**
  * Auditable soft deprecation. The catalog record, checkout, and every
- * historical Task/Run/Review/Integration/Publication reference are retained;
+ * historical Task/Turn/Review/Integration/Publication reference are retained;
  * the Project can no longer be bound to new work or maintained. Hard removal
  * is a separate `project delete` decision.
  */
@@ -871,7 +871,7 @@ function retireProjectCommand(args, store, options) {
         `Retired project ${retired.project.id} (${retired.project.name})`,
         `Reason: ${parsed.reason}`,
         `Retired by: ${retiredBy} at ${retired.project.retirement?.retiredAt ?? "?"}`,
-        "The catalog record, checkout, and historical Task/Run/Review/Integration/Publication evidence are retained.",
+        "The catalog record, checkout, and historical Task/Turn/Review/Integration/Publication evidence are retained.",
         ...(retired.references.boundTaskIds.length === 0
             ? []
             : [`Historical Task bindings retained: ${retired.references.boundTaskIds.join(", ")}.`]),
@@ -923,7 +923,7 @@ async function deleteProjectCommand(args, store, options) {
     const tombstone = join(store.rootDirectory(), "projects", `.delete-${project.id}`);
     const releaseMaintenance = acquireProjectMaintenanceLock(store.rootDirectory(), project.id);
     try {
-        // Heal a crashed earlier attempt before the prechecks run.
+        // Heal a crashed earlier attempt before the prechecks turn.
         await healCheckoutSwap({ currentPath: project.path, backupPath: tombstone });
         if (existsSync(project.path)) {
             const git = options.git ?? new NodeGitWorkspace();
@@ -998,7 +998,7 @@ function removeRetiredProjectRecord(store, projectId) {
         if (references.boundTaskIds.length > 0) {
             throw usageError(`Project cannot be deleted while Task records reference it: ${latest.id}. `
                 + `Bound Tasks: ${references.boundTaskIds.join(", ")}. `
-                + "Historical Task/Run/Review/Integration/Publication evidence must stay resolvable; keep the Project retired instead.");
+                + "Historical Task/Turn/Review/Integration/Publication evidence must stay resolvable; keep the Project retired instead.");
         }
         if (!tx.removeProject(latest.id)) {
             throw new Error(`Project was already removed: ${latest.id}.`);

package/dist/commands/releaseCommands.js

@@ -355,16 +355,9 @@ export function createReleaseActivatePorts(overrides = {}) {
                 throw new Error(`Release preflight produced no JSON (exit ${result.status}): `
                     + `${messageOf(error)} ${result.stderr.trim()}`);
             }
-            // The handover preflight is a compatibility check: the new release must
-            // understand the Home's storage schema and layout. The four-state
-            // `storage compatibility` verdict is authoritative: it is `ok` for
-            // current, compatible-old, and migration-required (MIGRATABLE) Homes,
-            // and non-ok for needs-new-version or corrupted Homes. The strict
-            // `storage schema` check reads `unsupported` for a MIGRATABLE Home even
-            // though the Controller opens it through the compatible migration path,
-            // so gating on it would reject every older-but-upgradable Home. A
-            // missing `storage state` (a Home that never ran `yui setup`) is not a
-            // compatibility blocker — the new Controller initializes it.
+            // The handover preflight must prove the exact current Home contract.
+            // Older, newer, malformed, or incomplete Homes all fail closed and are
+            // never normalized by release activation.
             const checks = report?.checks;
             if (!Array.isArray(checks)) {
                 throw new Error("Release preflight report has no storage checks.");

package/dist/commands/resourcesCommands.js

@@ -123,11 +123,11 @@ function collectTaskStatuses(store) {
     }
     return statuses;
 }
-/** Workspace paths claimed by active durable Jobs (AgentRuns). */
+/** Workspace paths claimed by active durable Jobs (Turns). */
 function collectActiveWorkspaceOwnerPaths(store) {
     const paths = [];
     for (const task of store.listTasks()) {
-        for (const run of store.listAgentRuns(task.id)) {
+        for (const run of store.listTurns(task.id)) {
             if (run.status !== "active")
                 continue;
             const workspace = run.workspace;

package/dist/commands/sessionCommands.js

@@ -28,7 +28,7 @@ export async function runSessionStopCommand(input) {
         // lifecycle work that may exist without a current Session candidate.
         await input.runtime.drainController();
         await input.runtime.stopController();
-        // Re-read the authoritative facts after the drain because a Run that was
+        // Re-read the authoritative facts after the drain because a Turn that was
         // already inside a pass may have changed state meanwhile.
         const settled = input.runtime.snapshot();
         const blockedAfterDrain = blockedSessions(settled);
@@ -80,7 +80,7 @@ function blockedSessions(input) {
     });
 }
 function blockedStopResult(blocked) {
-    const details = blocked.map(({ session }) => (`- ${renderSessionOwner(session)} (an active Run or lifecycle operation is still pending)`));
+    const details = blocked.map(({ session }) => (`- ${renderSessionOwner(session)} (an active Turn or lifecycle operation is still pending)`));
     return {
         output: [
             `Cannot stop managed Sessions: ${blocked.length} Session(s) are still busy.`,

package/dist/commands/taskActor.js

@@ -1,9 +1,8 @@
 import { usageError } from "../errors/cliError.js";
 import { activeRoleAgentBinding } from "../role/role.js";
-import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
-import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
+import { managedProviderTurnId } from "../runtime/providerRuntimeIdentity.js";
 const LEADER_ROLE = "leader";
-const LEADER_ACTION_RUN_ENV = "YUI_LEADER_ACTION_RUN_ID";
+const LEADER_ACTION_RUN_ENV = "YUI_LEADER_ACTION_TURN_ID";
 const LEADER_ACTION_RECEIPT_ENV = "YUI_LEADER_ACTION_RECEIPT_ID";
 /** rr13: Per-Session DurableJob caller key injected at native Session launch. */
 const JOB_CALLER_KEY_ENV = "YUI_JOB_CALLER_KEY";
@@ -24,7 +23,7 @@ export function taskActor(environment, taskId) {
     }
     if (env.YUI_ROLE !== undefined
         || env.YUI_AGENT_ID !== undefined
-        || env.YUI_RUN_ID !== undefined
+        || env.YUI_TURN_ID !== undefined
         || env.YUI_NATIVE_SESSION_ID !== undefined) {
         throw usageError("Managed Agent identity is incomplete; refusing to infer user authority.");
     }
@@ -34,17 +33,15 @@ export function taskActor(environment, taskId) {
  * Resolve authority for a recoverable Task-local mutation. A managed Leader
  * does not gain that authority from long-lived process environment alone: the
  * command must carry the exact current Turn assertion and it must still match
- * the durable active Run, receipt, Role binding, native Session, and Home.
+ * the durable active Turn, receipt, Role binding, native Session, and Home.
  * Plain-user and global-Operator behavior remains unchanged.
  */
 export function taskLocalActor(store, environment, taskId, yuiHome) {
     const actor = taskActor(environment, taskId);
     if (actor !== "leader")
         return actor;
-    const assertion = leaderActionAssertion(environment ?? {});
-    if (assertion === undefined || assertion === "invalid"
-        || taskLeaderActionRunId(store, taskId, environment, yuiHome) === undefined) {
-        throw usageError(`Task-local Leader authority requires the exact current-Turn assertion: ${taskId}.`);
+    if (taskLeaderActionTurnId(store, taskId, environment, yuiHome) === undefined) {
+        throw usageError(`Task-local Leader authority requires the current Provider Turn: ${taskId}.`);
     }
     return actor;
 }
@@ -59,7 +56,7 @@ export function projectActor(environment) {
     }
     if (env.YUI_ROLE !== undefined
         || env.YUI_AGENT_ID !== undefined
-        || env.YUI_RUN_ID !== undefined
+        || env.YUI_TURN_ID !== undefined
         || env.YUI_NATIVE_SESSION_ID !== undefined) {
         throw usageError("Managed Agent identity is incomplete; refusing to infer user authority.");
     }
@@ -72,8 +69,8 @@ export function projectActor(environment) {
  *
  * rr12: The identity is now Controller-verified rather than self-reported:
  * - A managed Task Session (`YUI_SESSION_SCOPE=task`) returns `scope: "task"`
- *   with its Role and Run. For a Leader, the explicit current-Turn Run id is
- *   preferred over a possibly stale `YUI_RUN_ID`.
+ *   with its Role and Turn. For a Leader, the explicit current Turn id is
+ *   preferred over a possibly stale `YUI_TURN_ID`.
  *
  * rr13: A managed Task Session also carries `callerKey` — the
  * `YUI_JOB_CALLER_KEY` injected at its native Session launch. The Controller
@@ -83,7 +80,7 @@ export function projectActor(environment) {
  * managed global Agent carries its own durable Session identity.
  *
  * A managed Task Session may only start jobs for its own Task. An incomplete
- * managed identity (role/agent/run/session vars without a scope) is rejected
+ * managed identity (role/agent/Turn/Session vars without a scope) is rejected
  * rather than silently downgraded to user authority.
  */
 export function resolveJobCaller(environment, taskId) {
@@ -98,14 +95,14 @@ export function resolveJobCaller(environment, taskId) {
         // Controller boundary.
         const callerKey = env[JOB_CALLER_KEY_ENV];
         if (role === LEADER_ROLE) {
-            // Prefer the explicit current-Turn Run over a possibly stale YUI_RUN_ID.
+            // Prefer the explicit current Turn over a possibly stale YUI_TURN_ID.
             const assertion = leaderActionAssertion(env);
             if (assertion !== undefined && assertion !== "invalid") {
                 return {
                     scope: "task",
                     taskId,
                     role,
-                    runId: assertion.runId,
+                    turnId: assertion.turnId,
                     ...(callerKey === undefined ? {} : { callerKey })
                 };
             }
@@ -114,7 +111,7 @@ export function resolveJobCaller(environment, taskId) {
             scope: "task",
             taskId,
             role,
-            ...(env.YUI_RUN_ID === undefined ? {} : { runId: env.YUI_RUN_ID }),
+            ...(env.YUI_TURN_ID === undefined ? {} : { turnId: env.YUI_TURN_ID }),
             ...(callerKey === undefined ? {} : { callerKey })
         };
     }
@@ -130,25 +127,25 @@ export function resolveJobCaller(environment, taskId) {
     }
     if (env.YUI_ROLE !== undefined
         || env.YUI_AGENT_ID !== undefined
-        || env.YUI_RUN_ID !== undefined
+        || env.YUI_TURN_ID !== undefined
         || env.YUI_NATIVE_SESSION_ID !== undefined) {
         throw usageError("Managed Agent identity is incomplete; refusing to infer user authority.");
     }
     return { scope: "user" };
 }
 /**
- * Resolve an exact current Task Leader Run for event attribution.
+ * Resolve an exact current Task Leader Turn for event attribution.
  *
  * Task commands may be invoked by a managed process whose environment is
- * stale, incomplete, or copied from another Run.  A bare YUI_RUN_ID is never
- * enough: the active durable Run, Role, in-flight receipt, native Session,
+ * stale, incomplete, or copied from another Turn. A bare YUI_TURN_ID is never
+ * enough: the active durable Turn, Role, in-flight receipt, native Session,
  * launch generation, and (when supplied) Home must all agree before an
  * allowlisted lifecycle event can buy a Leader action window.  A fixed native
- * Session may keep an earlier Run/launch in its process environment; in that
+ * Session may keep an earlier Turn/launch in its process environment; in that
  * case the current Leader turn must explicitly carry the exact durable
- * Run/receipt pair through the two command-only assertion variables below.
+ * Turn/receipt pair through the two command-only assertion variables below.
  */
-export function taskLeaderActionRunId(store, taskId, environment, yuiHome) {
+export function taskLeaderActionTurnId(store, taskId, environment, yuiHome) {
     const env = environment ?? {};
     if (env.YUI_SESSION_SCOPE !== "task" || env.YUI_ROLE !== LEADER_ROLE)
         return undefined;
@@ -158,12 +155,13 @@ export function taskLeaderActionRunId(store, taskId, environment, yuiHome) {
     if (environmentAssertion === "invalid")
         return undefined;
     const explicitAssertion = environmentAssertion === undefined ? undefined : environmentAssertion;
-    const runId = explicitAssertion?.runId ?? identity(env.YUI_RUN_ID);
+    const observedTurnTurnId = managedProviderTurnId(store.getTaskRoleSessionSet(taskId, LEADER_ROLE)?.providerBinding?.turn) ?? undefined;
+    const turnId = explicitAssertion?.turnId ?? observedTurnTurnId ?? identity(env.YUI_TURN_ID);
     const agentId = identity(env.YUI_AGENT_ID);
     const adapterId = identity(env.YUI_ADAPTER_ID);
     const launchId = identity(env.YUI_LAUNCH_ID);
     const home = identity(env.YUI_HOME);
-    if (runId === undefined
+    if (turnId === undefined
         || agentId === undefined
         || adapterId === undefined
         || launchId === undefined
@@ -178,12 +176,12 @@ export function taskLeaderActionRunId(store, taskId, environment, yuiHome) {
     if (yuiHome === undefined && storeHome !== undefined && home !== storeHome)
         return undefined;
     const role = store.getRole(taskId, LEADER_ROLE);
-    const run = store.getActiveAgentRun(taskId, LEADER_ROLE);
+    const run = store.getActiveTurn(taskId, LEADER_ROLE);
     const sessions = store.getTaskRoleSessionSet(taskId, LEADER_ROLE);
     if (role === null
         || run === null
         || run.status !== "active"
-        || run.id !== runId
+        || run.id !== turnId
         || run.taskId !== taskId
         || run.roleName !== LEADER_ROLE
         || run.effective.agentId !== agentId
@@ -195,13 +193,7 @@ export function taskLeaderActionRunId(store, taskId, environment, yuiHome) {
         || sessions.owner.taskId !== taskId
         || sessions.owner.roleName !== LEADER_ROLE
         || sessions.activeAgentId !== agentId
-        || sessions.inFlight === null
-        || sessions.inFlight.runId !== runId
-        || sessions.inFlight.agentId !== agentId
-        || sessions.inFlight.receiptId !== agentRunDeliveryReceiptId(run))
-        return undefined;
-    if (explicitAssertion !== undefined
-        && explicitAssertion.receiptId !== formatAgentRunReceiptId(taskId, runId))
+        || managedProviderTurnId(sessions.providerBinding?.turn) !== turnId)
         return undefined;
     const session = sessions.sessions[agentId];
     if (session === undefined
@@ -217,15 +209,15 @@ export function taskLeaderActionRunId(store, taskId, environment, yuiHome) {
     return run.id;
 }
 function leaderActionAssertion(environment) {
-    const runId = environment[LEADER_ACTION_RUN_ENV];
+    const turnId = environment[LEADER_ACTION_RUN_ENV];
     const receiptId = environment[LEADER_ACTION_RECEIPT_ENV];
-    if (runId === undefined && receiptId === undefined)
+    if (turnId === undefined && receiptId === undefined)
         return undefined;
-    const normalizedRunId = identity(runId);
+    const normalizedTurnId = identity(turnId);
     const normalizedReceiptId = identity(receiptId);
-    return normalizedRunId === undefined || normalizedReceiptId === undefined
+    return normalizedTurnId === undefined || normalizedReceiptId === undefined
         ? "invalid"
-        : { runId: normalizedRunId, receiptId: normalizedReceiptId };
+        : { turnId: normalizedTurnId, receiptId: normalizedReceiptId };
 }
 function identity(value) {
     if (typeof value !== "string" || value.includes("\0"))

package/dist/commands/taskChangeSetCommands.js

@@ -1,8 +1,6 @@
 import { usageError } from "../errors/cliError.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
-/**
- * Read-only ChangeSet inspection, including its optional integration manifest.
- */
+/** Read-only ChangeSet inspection, including its integration manifest. */
 export async function runTaskChangeSetCommand(args, store) {
     const [command, ...rest] = args;
     if (command === "show")
@@ -47,14 +45,9 @@ function renderChangeSet(changeSet) {
         ...changeSet.changedPaths.map((path) => `  ${path}`),
         `Created: ${changeSet.createdAt}`
     ];
-    if (changeSet.manifest === undefined) {
-        lines.push("Manifest: -");
-    }
-    else {
-        const manifest = changeSet.manifest;
-        lines.push("Manifest:", `  Tags: ${manifest.tags.join(", ")}`, `  Deleted paths: ${manifest.deletedPaths.length}`, ...manifest.deletedPaths.map((path) => `    ${path}`), `  Target: ${manifest.targetRef ?? "-"}`, `  Evidence: ${manifest.evidenceRefs.length === 0
-            ? "-"
-            : manifest.evidenceRefs.join(", ")}`);
-    }
+    const manifest = changeSet.manifest;
+    lines.push("Manifest:", `  Tags: ${manifest.tags.join(", ")}`, `  Deleted paths: ${manifest.deletedPaths.length}`, ...manifest.deletedPaths.map((path) => `    ${path}`), `  Target: ${manifest.targetRef ?? "-"}`, `  Evidence: ${manifest.evidenceRefs.length === 0
+        ? "-"
+        : manifest.evidenceRefs.join(", ")}`);
     return `${lines.join("\n")}\n`;
 }