@zq-silk/yui 0.13.9 → 0.14.0

package/dist/commands/taskWorkspaceCommands.js

@@ -1,89 +1,17 @@
 import { usageError } from "../errors/cliError.js";
 import { createMilestone } from "../milestone/milestone.js";
-import { defaultTableWidth, renderTable } from "../output/table.js";
 import { runTaskCommand } from "./taskCommands.js";
 /**
- * Task workspace lifecycle commands that sit outside the sync task command
- * surface because they drive Git: controlled rebuild of a legacy Task
- * workspace, legacy ref history inspection/archival, and the
- * replacement-creating path for terminal Tasks.
+ * Task workspace lifecycle command that sits outside the sync task command
+ * surface because replacement preserves the terminal Task and creates a new
+ * current-contract Task.
  */
 export async function runTaskWorkspaceCommand(args, store, preparer, options = {}) {
     const [command, ...rest] = args;
-    if (command === "rebuild")
-        return rebuildTaskCommand(rest, preparer);
-    if (command === "history")
-        return historyCommand(rest, preparer);
+    void preparer;
     if (command === "replace")
         return replaceTaskCommand(rest, store, options);
-    throw usageError("Unknown task workspace command. Available: yui task rebuild <task>, "
-        + "yui task history list|archive [task], yui task replace <task>.");
-}
-async function rebuildTaskCommand(args, preparer) {
-    const usage = "Task rebuild usage: yui task rebuild <task> [--latest].";
-    const taskId = args[0];
-    const options = new Set(args.slice(1));
-    if (taskId === undefined
-        || options.size !== args.length - 1
-        || [...options].some((option) => option !== "--latest")) {
-        throw usageError(usage);
-    }
-    const result = await preparer.rebuildTaskWorkspace(taskId, {
-        latestRemote: options.has("--latest")
-    });
-    const archived = result.archived.length === 0
-        ? "no legacy refs"
-        : `${result.archived.length} legacy ref(s) archived`;
-    const resumed = result.resumed ? " (resumed pending cleanup)" : "";
-    return {
-        output: `Rebuilt Task workspace ${result.task.id} at ${result.task.cwd ?? "its configured workspace"}: `
-            + `${archived}${resumed}.`,
-        data: {
-            taskId: result.task.id,
-            archived: result.archived,
-            resumed: result.resumed,
-            latestRemote: options.has("--latest")
-        }
-    };
-}
-async function historyCommand(args, preparer) {
-    const usage = "Task history usage: yui task history list|archive [task].";
-    const action = args[0];
-    if (action !== "list" && action !== "archive")
-        throw usageError(usage);
-    const taskId = args[1];
-    if (args.length > 2)
-        throw usageError(usage);
-    if (action === "list") {
-        const refs = await preparer.listLegacyTaskRefs(taskId);
-        if (refs.length === 0) {
-            return { output: "No legacy Task refs.", data: { refs: [] } };
-        }
-        return {
-            output: renderTable("Legacy Task refs", [
-                { header: "Project", minWidth: 8, maxWidth: 24 },
-                { header: "Task", minWidth: 8, maxWidth: 16 },
-                { header: "Legacy ref", minWidth: 16, maxWidth: 64 }
-            ], refs.map((entry) => [entry.projectId, entry.taskId, entry.ref]), defaultTableWidth()),
-            data: { refs }
-        };
-    }
-    const result = await preparer.archiveLegacyTaskRefs(taskId);
-    const lines = [];
-    if (result.archived.length > 0) {
-        lines.push(`Archived ${result.archived.length} legacy ref(s):`);
-        lines.push(...result.archived.map((entry) => `  ${entry}`));
-    }
-    if (result.refused.length > 0) {
-        lines.push(`Refused ${result.refused.length} live ref(s) owned by an open Task:`);
-        lines.push(...result.refused.map((entry) => `  ${entry}`));
-    }
-    if (lines.length === 0)
-        lines.push("No legacy Task refs to archive.");
-    return {
-        output: lines.join("\n"),
-        data: { archived: result.archived, refused: result.refused }
-    };
+    throw usageError("Unknown task workspace command. Available: yui task replace <task>.");
 }
 /**
  * A terminal (retired/completed/archived) Task is never rewritten in place.
@@ -100,10 +28,10 @@ function replaceTaskCommand(args, store, options) {
     if (old === null)
         throw usageError(`Task not found: ${oldId}.`);
     if (old.status === "draft") {
-        throw usageError(`Draft Task ${old.id} owns no workspace to replace or rebuild; activate it or retire it and create a new Draft.`);
+        throw usageError(`Draft Task ${old.id} owns no completed history to replace; activate it or retire it and create a new Draft.`);
     }
     if (old.status === "active") {
-        throw usageError(`Active Task can be rebuilt instead of replaced: ${old.id}.`);
+        throw usageError(`Active Task cannot be replaced: ${old.id}.`);
     }
     let title = `Replaces ${old.id}: ${old.title}`;
     for (let index = 1; index < args.length; index += 1) {

package/dist/commands/telemetryCommands.js

@@ -1,13 +1,9 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { usageError } from "../errors/cliError.js";
-import { STORAGE_SCHEMA_FILE } from "../storage/storageSchema.js";
 import { CURRENT_CONFIG_SCHEMA_VERSION } from "../storage/taskStore.js";
-import { openTaskStore, SqliteTaskStore } from "../storage/sqliteStore.js";
-import { COMMITTED_DATABASE_FILENAME } from "../storage/upgrade/sqliteStateMigration.js";
-import { DEFAULT_RUN_CAP, DEFAULT_TERMINAL_KEEP, resolveRunCap, resolveTerminalKeep } from "../telemetry/telemetryConfig.js";
+import { CURRENT_DATABASE_FILENAME as COMMITTED_DATABASE_FILENAME } from "../storage/currentTaskStore.js";
+import { DEFAULT_TERMINAL_KEEP, resolveTurnCap, resolveTerminalKeep } from "../telemetry/telemetryConfig.js";
 import { resolveTelemetryEnabled } from "../config/yuiConfig.js";
-import { applyTelemetryCompaction, planTelemetryCompaction } from "../telemetry/telemetryCompaction.js";
 import { SqliteTelemetryStore } from "../telemetry/sqliteTelemetryStore.js";
 /** Read the durable config, falling back to defaults when no store is available. */
 function storeConfig(options) {
@@ -22,16 +18,13 @@ export async function runTelemetryCommand(args, options) {
         return telemetryStatus(rest, options);
     if (command === "prune")
         return telemetryPrune(rest, options);
-    if (command === "compact")
-        return telemetryCompact(rest, options);
     if (command === "read")
         return telemetryRead(rest, options);
     throw usageError(command === undefined
-        ? "Telemetry command is required: status, prune, compact, or read."
+        ? "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 compact --from <home> --staged <dir> [--keep <n>] [--dry-run] [--json]\n"
-        + "yui telemetry read --task <id> [--run <id>] [--aggregate] [--limit <n>] [--offset <n>]");
+        + "yui telemetry read --task <id> [--turn <id>] [--aggregate] [--limit <n>] [--offset <n>]");
 }
 // -- status ---------------------------------------------------------------------
 function telemetryStatus(args, options) {
@@ -40,7 +33,7 @@ function telemetryStatus(args, options) {
     const telemetry = new SqliteTelemetryStore(options.home, {
         mode,
         terminalKeep: resolveTerminalKeep(storeConfig(options).telemetryTerminalKeep),
-        runCap: resolveRunCap(storeConfig(options).telemetryRunCap)
+        turnCap: resolveTurnCap(storeConfig(options).telemetryTurnCap)
     });
     try {
         const health = telemetry.health();
@@ -50,7 +43,7 @@ function telemetryStatus(args, options) {
             : store.listTasks().map((task) => ({
                 taskId: task.id,
                 rows: telemetry.count(task.id),
-                runs: telemetry.listRunAggregates(task.id).length
+                turns: telemetry.listTurnAggregates(task.id).length
             }));
         const report = {
             mode,
@@ -61,7 +54,7 @@ function telemetryStatus(args, options) {
             lastError: health.lastError,
             totalRows: health.rows,
             terminalKeep: resolveTerminalKeep(storeConfig(options).telemetryTerminalKeep),
-            runCap: resolveRunCap(storeConfig(options).telemetryRunCap),
+            turnCap: resolveTurnCap(storeConfig(options).telemetryTurnCap),
             tasks: perTask
         };
         if (options.json || flags.has("json"))
@@ -75,10 +68,10 @@ function telemetryStatus(args, options) {
             `Coalesced:       ${health.coalesced}`,
             ...(health.lastError === null ? [] : [`Last error:      ${health.lastError}`]),
             `Terminal keep:   ${report.terminalKeep}`,
-            `Run cap:         ${report.runCap}`
+            `Turn cap:        ${report.turnCap}`
         ];
         for (const task of perTask) {
-            lines.push(`  ${task.taskId}: ${task.rows} rows across ${task.runs} run generation(s)`);
+            lines.push(`  ${task.taskId}: ${task.rows} rows across ${task.turns} Turn generation(s)`);
         }
         return lines.join("\n");
     }
@@ -92,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 = resolveRunCap(storeConfig(options).telemetryRunCap);
+    const cap = resolveTurnCap(storeConfig(options).telemetryTurnCap);
     const store = requireStore(options);
     const telemetry = new SqliteTelemetryStore(options.home, {
         mode: telemetryMode(storeConfig(options)),
         terminalKeep: keep,
-        runCap: cap
+        turnCap: cap
     });
     try {
         const tasks = taskId === undefined
@@ -105,35 +98,35 @@ function telemetryPrune(args, options) {
             : [taskId];
         const report = [];
         for (const id of tasks) {
-            const terminalRuns = new Set(store.listAgentRuns(id)
+            const terminalTurns = new Set(store.listTurns(id)
                 .filter((run) => run.status !== "active")
                 .map((run) => run.id));
             const entry = { taskId: id, terminalPruned: 0, activeCapped: 0, generations: [] };
-            for (const aggregate of telemetry.listRunAggregates(id)) {
-                if (terminalRuns.has(aggregate.runId)) {
-                    const before = telemetry.count(id, aggregate.runId);
+            for (const aggregate of telemetry.listTurnAggregates(id)) {
+                if (terminalTurns.has(aggregate.turnId)) {
+                    const before = telemetry.count(id, aggregate.turnId);
                     const deleted = dryRun
                         ? Math.max(0, before - keep)
-                        : telemetry.pruneGeneration(aggregate.taskId, aggregate.roleName, aggregate.runId, aggregate.generation, keep);
+                        : telemetry.pruneGeneration(aggregate.taskId, aggregate.roleName, aggregate.turnId, aggregate.generation, keep);
                     entry.terminalPruned += deleted;
                     entry.generations.push({
-                        runId: aggregate.runId,
+                        turnId: aggregate.turnId,
                         generation: aggregate.generation,
                         kept: Math.min(before, keep),
                         deleted
                     });
                 }
             }
-            for (const run of store.listAgentRuns(id)) {
+            for (const run of store.listTurns(id)) {
                 if (run.status !== "active")
                     continue;
                 const before = telemetry.count(id, run.id);
                 if (before <= cap)
                     continue;
-                const deleted = dryRun ? before - cap : telemetry.capRun(id, run.id, cap);
+                const deleted = dryRun ? before - cap : telemetry.capTurn(id, run.id, cap);
                 entry.activeCapped += deleted;
                 entry.generations.push({
-                    runId: run.id,
+                    turnId: run.id,
                     generation: "*",
                     kept: Math.min(before, cap),
                     deleted
@@ -151,14 +144,14 @@ function telemetryPrune(args, options) {
         const lines = [
             `Telemetry prune (${dryRun ? "dry-run" : "applied"}):`,
             `  terminal generations pruned: ${totals.terminalPruned} row(s) (keep ${keep})`,
-            `  active runs capped:          ${totals.activeCapped} row(s) (cap ${cap})`
+            `  active Turns capped:         ${totals.activeCapped} row(s) (cap ${cap})`
         ];
         for (const entry of report) {
             if (entry.generations.length === 0)
                 continue;
             lines.push(`  ${entry.taskId}:`);
             for (const generation of entry.generations) {
-                lines.push(`    ${generation.runId}/${generation.generation}: kept ${generation.kept}, deleted ${generation.deleted}`);
+                lines.push(`    ${generation.turnId}/${generation.generation}: kept ${generation.kept}, deleted ${generation.deleted}`);
             }
         }
         return lines.join("\n");
@@ -167,105 +160,38 @@ function telemetryPrune(args, options) {
         void telemetry.close();
     }
 }
-// -- compact --------------------------------------------------------------------
-function telemetryCompact(args, options) {
-    const flags = parseFlags(args, new Set(["dry-run", "json"]));
-    const from = stringOption(args, "--from");
-    const staged = stringOption(args, "--staged");
-    const keep = integerOption(args, "--keep", DEFAULT_TERMINAL_KEEP);
-    const dryRun = flags.has("dry-run");
-    if (from === undefined || staged === undefined) {
-        throw usageError("telemetry compact requires --from <home> and --staged <dir>.", "yui telemetry compact --from <home> --staged <dir> [--keep <n>] [--dry-run]");
-    }
-    const resolvedFrom = resolvePath(from);
-    const resolvedStaged = resolvePath(staged);
-    if (resolvedFrom === resolvedStaged) {
-        throw usageError("--from and --staged must be different directories.");
-    }
-    if (!existsSync(join(resolvedFrom, STORAGE_SCHEMA_FILE))) {
-        throw usageError(`--from is not a Yui Home (missing ${STORAGE_SCHEMA_FILE}): ${resolvedFrom}`);
-    }
-    if (existsSync(resolvedStaged) && dryRun === false) {
-        throw usageError(`--staged already exists; refuse to overwrite: ${resolvedStaged}`);
-    }
-    // Database-only direction: compaction folds semantic progress into the
-    // telemetry tables inside `yui.db`. A Home without a database has not
-    // reached SQLite storage yet; migrate it first (yui upgrade) instead
-    // of silently compacting a file-only copy that telemetry cannot join.
-    if (!existsSync(join(resolvedFrom, COMMITTED_DATABASE_FILENAME))) {
-        throw usageError(`--from is not a SQLite Home (missing ${COMMITTED_DATABASE_FILENAME}): ${resolvedFrom}. `
-            + "Migrate it to the database backend before compaction.");
-    }
-    const backend = "sqlite";
-    mkdirSync(resolvedStaged, { recursive: true });
-    copyStoreFiles(resolvedFrom, resolvedStaged);
-    const store = openTaskStore(resolvedStaged, backend);
-    const telemetry = new SqliteTelemetryStore(resolvedStaged, {
-        mode: "on",
-        terminalKeep: keep,
-        runCap: DEFAULT_RUN_CAP
-    });
-    try {
-        const plan = planTelemetryCompaction(store, { terminalKeep: keep });
-        const receipt = applyTelemetryCompaction(store, telemetry, plan, {
-            dryRun,
-            source: resolvedFrom,
-            terminalKeep: keep
-        });
-        writeFileSync(join(resolvedStaged, "telemetry-compaction.json"), JSON.stringify(receipt, null, 2) + "\n");
-        if (options.json || flags.has("json"))
-            return JSON.stringify({ staged: resolvedStaged, receipt }, null, 2);
-        return [
-            `Telemetry compaction (${dryRun ? "dry-run" : "applied"}) on staged copy:`,
-            `  staged:       ${resolvedStaged}`,
-            `  backend:      ${backend}`,
-            `  tasks:        ${receipt.totals.tasks}`,
-            `  progress:     ${receipt.totals.progressEvents} event(s) across ${receipt.totals.generations} generation(s)`,
-            `  sidecar rows: ${receipt.totals.telemetryRows} (window ${keep}/generation)`,
-            `  receipt:      ${join(resolvedStaged, "telemetry-compaction.json")}`,
-            dryRun
-                ? "Dry-run made no changes. Re-run without --dry-run, then promote the staged Home after verifying the receipt."
-                : "Applied. Promote the staged Home only after verifying the receipt; the original Home is unchanged."
-        ].join("\n");
-    }
-    finally {
-        void telemetry.close();
-        if (store instanceof SqliteTaskStore)
-            store.close();
-    }
-}
 // -- read -----------------------------------------------------------------------
 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> [--run <id>] [--aggregate]");
+        throw usageError("telemetry read requires --task <id>.", "yui telemetry read --task <id> [--turn <id>] [--aggregate]");
     }
-    const runId = stringOption(args, "--run");
+    const turnId = stringOption(args, "--turn");
     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),
-        runCap: resolveRunCap(storeConfig(options).telemetryRunCap)
+        turnCap: resolveTurnCap(storeConfig(options).telemetryTurnCap)
     });
     try {
         if (flags.has("aggregate")) {
-            if (runId === undefined) {
-                const aggregates = telemetry.listRunAggregates(taskId);
+            if (turnId === undefined) {
+                const aggregates = telemetry.listTurnAggregates(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, runId);
+            const aggregate = telemetry.aggregate(taskId, turnId);
             if (options.json || flags.has("json"))
                 return JSON.stringify(aggregate, null, 2);
-            return aggregate === null ? "(no telemetry for this Run)" : formatAggregate(aggregate);
+            return aggregate === null ? "(no telemetry for this Turn)" : formatAggregate(aggregate);
         }
-        const page = telemetry.list(taskId, runId, { limit, offset });
+        const page = telemetry.list(taskId, turnId, { limit, offset });
         if (options.json || flags.has("json"))
             return JSON.stringify(page, null, 2);
-        const lines = page.items.map((entry) => `${entry.receivedAt} ${entry.runId}/${entry.generation}/${entry.progressId}`
+        const lines = page.items.map((entry) => `${entry.receivedAt} ${entry.turnId}/${entry.generation}/${entry.progressId}`
             + `${entry.sequence === undefined ? "" : ` seq=${entry.sequence}`}`);
         if (page.nextOffset !== null)
             lines.push(`(next offset: ${page.nextOffset})`);
@@ -282,24 +208,6 @@ function requireStore(options) {
     }
     return options.store;
 }
-function resolvePath(value) {
-    return value.startsWith("/") ? value : join(process.cwd(), value);
-}
-function copyStoreFiles(from, staged) {
-    for (const filename of [
-        COMMITTED_DATABASE_FILENAME,
-        `${COMMITTED_DATABASE_FILENAME}-wal`,
-        `${COMMITTED_DATABASE_FILENAME}-shm`
-    ]) {
-        const source = join(from, filename);
-        if (existsSync(source))
-            copyFile(source, join(staged, filename));
-    }
-    copyFile(join(from, STORAGE_SCHEMA_FILE), join(staged, STORAGE_SCHEMA_FILE));
-}
-function copyFile(source, destination) {
-    writeFileSync(destination, readFileSync(source));
-}
 function parseFlags(args, known) {
     const flags = new Set();
     for (const arg of args) {
@@ -332,5 +240,5 @@ function integerOption(args, name, fallback) {
     return value;
 }
 function formatAggregate(aggregate) {
-    return `${aggregate.runId}/${aggregate.generation}: count=${aggregate.count} first=${aggregate.firstAt} last=${aggregate.lastAt} maxSequence=${aggregate.maxSequence === null ? "-" : aggregate.maxSequence} errors=${aggregate.errorCount}`;
+    return `${aggregate.turnId}/${aggregate.generation}: count=${aggregate.count} first=${aggregate.firstAt} last=${aggregate.lastAt} maxSequence=${aggregate.maxSequence === null ? "-" : aggregate.maxSequence} errors=${aggregate.errorCount}`;
 }

package/dist/commands/workflowCommands.js

@@ -61,9 +61,9 @@ export async function runWorkflowCommandAsync(args, store, options) {
     // first transition or calls an external system. A run that is killed,
     // crashes, or whose engine rethrows after this point can never leave
     // mutation or effect evidence without an audit record saying the run was
-    // attempted. FileTaskStore transactions are synchronous, so the async
-    // engine run cannot join this transaction; committing the intent first is
-    // what makes the trail crash-safe across the whole run.
+    // attempted. The async engine run cannot join this synchronous transaction;
+    // committing the intent first is
+    // what makes the trail crash-safe across the whole turn.
     const intentNow = clock(options);
     store.transaction((tx) => {
         recordTaskEvent(tx, taskId, "release-workflow.run-started", {

package/dist/completion/fileCompletionManager.js

@@ -1,6 +1,6 @@
 import { installCompletion } from "./completionInstaller.js";
 import { COMPLETION_SHELLS, completionActivationIsCurrent, completionScriptIsCurrent, currentCompletionShell, suggestedCompletionInstallation } from "./completionState.js";
-/** FileTaskStore-backed completion port used by the interactive CLI wizard. */
+/** Durable completion port used by the interactive CLI wizard. */
 export class FileCompletionManager {
     #store;
     #env;

package/dist/config/configCatalog.js

@@ -1,5 +1,4 @@
-import { MAX_RUN_CAP } from "../telemetry/telemetryConfig.js";
-import { MAX_CONTEXT_BUDGET_TOKENS, MIN_CONTEXT_BUDGET_TOKENS } from "./yuiConfig.js";
+import { MAX_TURN_CAP } from "../telemetry/telemetryConfig.js";
 export const CONFIG_DOMAINS = ["system", "runtime", "workflow", "resources", "tools"];
 /**
  * Public durable configuration contract. CLI help, completion, config show,
@@ -16,8 +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 yielded Leader turns without durable delivery progress before warning, 1-20 (default: 3).", takesEffect: "The next Leader delivery guard evaluation." },
-    { key: "context-budget", domain: "workflow", property: "contextBudget", label: "Legacy context budget (inactive)", summary: `Compatibility-only soft and hard values in ${MIN_CONTEXT_BUDGET_TOKENS}-${MAX_CONTEXT_BUDGET_TOKENS}; they are parsed but never control Session or workflow behavior.`, takesEffect: "No runtime effect; Session Token metrics are read-only observations." },
+    { 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: "review", domain: "workflow", property: "review", label: "Review", summary: "Optional global WorkItem review rule: a configured Role plus always, leader, or final trigger and optional finding-ledger behavior. 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." },
@@ -25,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 Run generation (default: 200).", takesEffect: "Explicit retention immediately; automatic retention after the Controller restarts." },
-    { key: "telemetry-run-cap", domain: "tools", property: "telemetryRunCap", label: "Telemetry Run cap", summary: `Positive-integer maximum rows retained per Run, at most ${MAX_RUN_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 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." }
 ]);
 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_RUN_CAP, DEFAULT_TERMINAL_KEEP, MAX_RUN_CAP } from "../telemetry/telemetryConfig.js";
+import { DEFAULT_TURN_CAP, DEFAULT_TERMINAL_KEEP, MAX_TURN_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 resolveTelemetryRunCap(value) {
+export function resolveTelemetryTurnCap(value) {
     if (value === undefined || value === null)
-        return DEFAULT_RUN_CAP;
+        return DEFAULT_TURN_CAP;
     if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
-        throw new TypeError("telemetryRunCap must be a positive integer.");
+        throw new TypeError("telemetryTurnCap must be a positive integer.");
     }
-    if (value > MAX_RUN_CAP) {
-        throw new TypeError(`telemetryRunCap must not exceed ${MAX_RUN_CAP.toLocaleString("en-US")} (retention cannot be disabled).`);
+    if (value > MAX_TURN_CAP) {
+        throw new TypeError(`telemetryTurnCap must not exceed ${MAX_TURN_CAP.toLocaleString("en-US")} (retention cannot be disabled).`);
     }
     return value;
 }
@@ -147,43 +147,6 @@ export function resolveLeaderSemanticBudgetTurns(value) {
 export function resolveTmuxHistoryLimit(value) {
     return resolveBoundedPositiveInteger(value, DEFAULT_TMUX_HISTORY_LIMIT, 1_000, 1_000_000, "tmuxHistoryLimit");
 }
-/**
- * Compatibility parser for the retired context-budget setting. Existing
- * Homes may retain these values, but no runtime, scheduler, or lifecycle path
- * consumes them. Session Token metrics are an independent read-only view.
- */
-export const DEFAULT_CONTEXT_SOFT_TOKENS = 100_000;
-export const DEFAULT_CONTEXT_HARD_TOKENS = 120_000;
-export const MIN_CONTEXT_BUDGET_TOKENS = 1_000;
-export const MAX_CONTEXT_BUDGET_TOKENS = 1_000_000;
-function resolveContextBudgetToken(value, label) {
-    if (typeof value !== "number" || !Number.isSafeInteger(value)) {
-        throw new TypeError(`${label} must be a safe integer.`);
-    }
-    if (value < MIN_CONTEXT_BUDGET_TOKENS || value > MAX_CONTEXT_BUDGET_TOKENS) {
-        throw new TypeError(`${label} must be between ${MIN_CONTEXT_BUDGET_TOKENS} and ${MAX_CONTEXT_BUDGET_TOKENS}.`);
-    }
-    return value;
-}
-export function resolveContextBudget(configured) {
-    if (configured === undefined || configured === null) {
-        return { softTokens: DEFAULT_CONTEXT_SOFT_TOKENS, hardTokens: DEFAULT_CONTEXT_HARD_TOKENS };
-    }
-    if (typeof configured !== "object" || Array.isArray(configured)) {
-        throw new TypeError("contextBudget must be an object.");
-    }
-    const record = configured;
-    const softTokens = record.softTokens === undefined
-        ? DEFAULT_CONTEXT_SOFT_TOKENS
-        : resolveContextBudgetToken(record.softTokens, "contextBudget.softTokens");
-    const hardTokens = record.hardTokens === undefined
-        ? DEFAULT_CONTEXT_HARD_TOKENS
-        : resolveContextBudgetToken(record.hardTokens, "contextBudget.hardTokens");
-    if (softTokens >= hardTokens) {
-        throw new TypeError("contextBudget.softTokens must be smaller than contextBudget.hardTokens.");
-    }
-    return { softTokens, hardTokens };
-}
 function resolveBoundedPositiveInteger(value, fallback, minimum, maximum, label) {
     if (value === undefined || value === null)
         return fallback;

package/dist/context/dispatchContext.js

@@ -1,7 +1,3 @@
-/** Compatibility entry point used by the restored Task workflow. */
-export function compileDispatchInput(_store, taskId, role, input, workContext = {}) {
-    return buildRoleContext({ taskId, role, input, ...workContext });
-}
 export function buildRoleContext(context) {
     return context.role.name === "leader"
         ? buildLeaderContext(context)
@@ -13,40 +9,28 @@ export function buildLeaderContext(context) {
 export function buildWorkerContext(context) {
     return renderDispatchContext("worker", context);
 }
-const WORKER_RUN_COMPLETION_MARKER = "Yui Role Run completion requirement:";
-const WORKER_RUN_COMPLETION_REQUIREMENT = [
-    WORKER_RUN_COMPLETION_MARKER,
-    "Before ending, read the exact current Run ID from the managed first line and execute "
-        + "`yui task run yield <current-run-id> --summary-file - <<'YUI_SUMMARY'` "
-        + "followed by the outcome, evidence, and a closing `YUI_SUMMARY` line, "
-        + "replacing the placeholder with that ID.",
+const WORKER_TURN_COMPLETION_MARKER = "Yui Role Turn result requirement:";
+const WORKER_TURN_COMPLETION_REQUIREMENT = [
+    WORKER_TURN_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.",
     "If you cannot finally determine success, failure, completeness, or the correct "
         + "disposition, do not guess, silently stop, or hide uncertainty behind a success "
-        + "summary. Use this exact yield path and label the handoff uncertain, incomplete, "
+        + "summary. Label the final report uncertain, incomplete, "
         + "blocked, or requiring Leader judgment.",
-    "Report the most complete truthful evidence available and, when applicable: exact Run, "
+    "Report the most complete truthful evidence available and, when applicable: exact Turn, "
         + "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.",
-    "Yield submits immutable Run evidence and a Candidate, or Review evidence only. It never "
-        + "implies Leader acceptance, WorkItem completion, ChangeSet capture, Integration, or "
-        + "Task completion. Review Runs report findings, verification gaps, and limits; the "
-        + "Leader decides disposition.",
-    "This exact control-plane permission does not grant repository writes, broad Bash, "
-        + "external effects, or cross-Run control.",
-    "If the exact yield is denied, do not retry, broaden permissions, use a wrapper, mutate "
-        + "Yui state, or invent delivery evidence. Truthfully surface the blocker through the "
-        + "supported provider failure boundary; there is no fallback protocol.",
-    "Yielding closes the Run and hands the WorkItem to the Leader for acceptance; "
-        + "a final response alone does neither.",
-    "The yield command must be your final tool action. After it succeeds, stop immediately: "
-        + "do not inspect, poll, accept, or perform any further work in the same native turn."
+    "The Provider turn ending closes only this Turn. It does not imply Leader acceptance, "
+        + "WorkItem completion, ChangeSet capture, Integration, or Task completion. Review Turns "
+        + "report findings, verification gaps, and limits; the Leader decides disposition."
 ].join("\n");
-export function ensureWorkerRunCompletionRequirement(input) {
-    return input.endsWith(`\n\n${WORKER_RUN_COMPLETION_REQUIREMENT}`)
+export function ensureWorkerTurnCompletionRequirement(input) {
+    return input.endsWith(`\n\n${WORKER_TURN_COMPLETION_REQUIREMENT}`)
         ? input
-        : `${input}\n\n${WORKER_RUN_COMPLETION_REQUIREMENT}`;
+        : `${input}\n\n${WORKER_TURN_COMPLETION_REQUIREMENT}`;
 }
 function renderDispatchContext(kind, context) {
     const profile = context.role;
@@ -74,7 +58,7 @@ function renderDispatchContext(kind, context) {
     ].filter((section) => section !== null && section.length > 0)
         .join("\n\n");
     return kind === "worker"
-        ? ensureWorkerRunCompletionRequirement(rendered)
+        ? ensureWorkerTurnCompletionRequirement(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 Run assignments deliberately remain outside this value.
+ * Dynamic wakeups and Turn assignments deliberately remain outside this value.
  */
 export function compileRoleSessionContext(yuiHome, role, owner, options = {}) {
     const kind = roleSessionKind(role, owner, options.purpose ?? "execution");
@@ -72,7 +72,7 @@ function renderRoleCore(kind, role, owner) {
         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 Run.",
+                "Review only the exact frozen ReviewRound scope assigned to this Turn.",
                 "Follow the injected yui-reviewer Skill while reviewing Yui work."
             ];
         case "worker":

package/dist/context/sessionBootstrapManifest.js

@@ -133,8 +133,8 @@ export function materializeSessionBootstrap(input) {
                 loadCommand: "\"$YUI_SESSION_CLI\" session context \"$YUI_ROLE\" --json"
             }
             : {
-                loadCommand: "\"$YUI_SESSION_CLI\" task run context \"$YUI_TASK_ID/<run-id>\" --json",
-                expandCommand: "\"$YUI_SESSION_CLI\" task run context expand \"$YUI_TASK_ID/<run-id>\" <ref-id> --store <store> --mode full --json"
+                loadCommand: "\"$YUI_SESSION_CLI\" task turn context \"$YUI_TASK_ID/<turn-id>\" --json",
+                expandCommand: "\"$YUI_SESSION_CLI\" task turn context expand \"$YUI_TASK_ID/<turn-id>\" <ref-id> --store <store> --mode full --json"
             }
     };
     const manifest = Object.freeze({ ...body, digest: digest(body) });