@zq-silk/yui 0.15.12 → 0.16.0

package/dist/commands/taskPublicationCommands.js

@@ -1,5 +1,4 @@
 import { isDeepStrictEqual } from "node:util";
-import { taskActor } from "./taskActor.js";
 import { dataError, taskNotFound, usageError } from "../errors/cliError.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
@@ -7,6 +6,7 @@ import { formatTimestamp } from "../output/timePresentation.js";
 import { resolveProject } from "../repository/project.js";
 import { createPublicationReference } from "../task/publicationReference.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
+import { taskActor } from "../task/taskAuthority.js";
 const PROVIDERS = new Set(["github", "gitlab"]);
 const EXTERNAL_KINDS = new Set(["pull-request", "merge-request"]);
 const STATES = new Set(["open", "merged", "closed"]);

package/dist/commands/taskPublicationVerifyCommand.js

@@ -1,5 +1,5 @@
 import { isDeepStrictEqual } from "node:util";
-import { taskActor } from "./taskActor.js";
+import { taskActor } from "../task/taskAuthority.js";
 import { upsertTaskPublication } from "./taskPublicationCommands.js";
 import { dataError, runtimeError, taskNotFound, usageError, CliError } from "../errors/cliError.js";
 import { publicationExternalKey } from "../task/publicationReference.js";

package/dist/commands/taskRemoteDeliveryCommand.js

@@ -1,6 +1,5 @@
-import { isDeepStrictEqual } from "node:util";
 import { taskNotFound, usageError } from "../errors/cliError.js";
-import { projectTaskRemoteDelivery } from "../task/remoteDelivery.js";
+import { projectTaskRemoteDeliveryFromStore } from "../task/remoteDeliveryService.js";
 export function runTaskRemoteDeliveryCommand(args, store, currentCandidate = null) {
     const usage = "Task remote-delivery usage: yui task remote-delivery <task> [--json].";
     const asJson = args.includes("--json");
@@ -9,7 +8,7 @@ export function runTaskRemoteDeliveryCommand(args, store, currentCandidate = nul
         throw usageError(usage);
     }
     const taskId = positionals[0].trim();
-    const data = store.transaction((reader) => {
+    const data = store.readTransaction((reader) => {
         const task = reader.getTask(taskId);
         if (task === null)
             throw taskNotFound(taskId);
@@ -23,85 +22,6 @@ export function runTaskRemoteDeliveryCommand(args, store, currentCandidate = nul
         data
     };
 }
-export function projectTaskRemoteDeliveryFromStore(store, task, currentCandidate = null) {
-    return projectTaskRemoteDelivery({
-        task,
-        events: store.listEvents(task.id),
-        publications: store.listPublicationReferences(task.id),
-        managedWorkspaces: store.listManagedWorkspaces(task.id),
-        runs: store.listRuns(task.id),
-        integrations: store.listIntegrationAttempts(task.id),
-        currentCandidate
-    });
-}
-export function createTaskRemoteDeliveryProof(store, task, currentCandidate = null) {
-    const publications = store.listPublicationReferences(task.id);
-    const delivery = projectTaskRemoteDelivery({
-        task,
-        events: store.listEvents(task.id),
-        publications,
-        managedWorkspaces: store.listManagedWorkspaces(task.id),
-        runs: store.listRuns(task.id),
-        integrations: store.listIntegrationAttempts(task.id),
-        currentCandidate
-    });
-    return {
-        schemaVersion: 1,
-        task: taskRemoteDeliveryProofTask(task),
-        publications,
-        delivery
-    };
-}
-export function assertTaskRemoteDeliveryProof(store, task, proof) {
-    if (proof === undefined || proof.schemaVersion !== 1) {
-        throw usageError(`Task remote-delivery preflight proof is required: ${task.id}.`);
-    }
-    if (!isDeepStrictEqual(proof.task, taskRemoteDeliveryProofTask(task))) {
-        throw usageError(`Task changed after remote-delivery preflight: ${task.id}.`);
-    }
-    if (!isDeepStrictEqual(proof.publications, store.listPublicationReferences(task.id))) {
-        throw usageError(`Task Publication evidence changed after remote-delivery preflight: ${task.id}.`);
-    }
-    // Recheck semantic adoption/Integration facts as well as Publication versions.
-    // For provisional cancelled Tasks retain the frozen candidate used at preflight.
-    const current = projectTaskRemoteDeliveryFromStore(store, task, {
-        projects: proof.delivery.projects.flatMap(p => p.expectedLocalCommit === null
-            ? [] : [{ projectId: p.projectId, commit: p.expectedLocalCommit }])
-    });
-    if (!isDeepStrictEqual(current, proof.delivery)) {
-        throw usageError(`Task delivery evidence changed after remote-delivery preflight: ${task.id}.`);
-    }
-    assertTaskRemoteDeliveryIntegrated(proof.delivery);
-    return proof.delivery;
-}
-export function assertTaskRemoteDeliveryIntegrated(delivery) {
-    if (!delivery.allMerged) {
-        const headUnavailable = delivery.projects.filter((project) => (project.codeDelivery !== "none"
-            && project.coverage === "head-unavailable"));
-        if (headUnavailable.length > 0 && delivery.source === "task-completed") {
-            throw usageError(`Task ${delivery.taskId} has no frozen completion heads for: ${headUnavailable.map(({ projectId }) => projectId).join(", ")}. Historical acceptance cannot be inferred from a merge or archive.`);
-        }
-        const uncovered = delivery.projects
-            .filter((project) => project.codeDelivery !== "none" && !project.merged)
-            .map((project) => (`${project.projectId}/${project.coverage}`
-            + (project.publication === null ? "" : `/${project.publication.id}`)))
-            .join(", ");
-        throw usageError(`Task ${delivery.taskId} is not fully merged into remote delivery: ${uncovered || "expected Project heads are unavailable"}. Inspect each Project reason with task remote-delivery. Record confirmed Publication facts; `
-            + "for a changed post-completion candidate, review publication diff and explicitly adopt its acceptance.");
-    }
-    if (delivery.allVerified)
-        return;
-    const unverified = delivery.projects
-        .filter((project) => (project.codeDelivery !== "none"
-        && project.merged
-        && !project.verified))
-        .map((project) => (`${project.projectId}/${project.coverage}`
-        + (project.publication === null ? "" : `/${project.publication.id}`)))
-        .join(", ");
-    throw usageError(`Task ${delivery.taskId} has merged Publication evidence that is not verified: `
-        + `${unverified || "verification evidence is unavailable"}. Run task publication verify `
-        + "for each Publication only when the provider read is authorized.");
-}
 export function renderTaskRemoteDelivery(delivery, indent = "") {
     const source = `${delivery.source}${delivery.provisional ? " (provisional)" : ""}`;
     const lines = [
@@ -131,15 +51,3 @@ export function renderTaskRemoteDelivery(delivery, indent = "") {
 function shortCommit(commit) {
     return commit === null ? "unknown" : commit.slice(0, 12);
 }
-function taskRemoteDeliveryProofTask(task) {
-    return {
-        id: task.id,
-        status: task.status,
-        projectBindings: task.projectBindings,
-        ...(task.workspaceIdentity === undefined
-            ? {}
-            : { workspaceIdentity: task.workspaceIdentity }),
-        ...(task.completedAt === undefined ? {} : { completedAt: task.completedAt }),
-        ...(task.retiredAt === undefined ? {} : { retiredAt: task.retiredAt })
-    };
-}

package/dist/commands/taskUpstreamCommands.js

@@ -1,11 +1,11 @@
+import { parseRepeatable } from "../cli/parseRepeatable.js";
 import { usageError } from "../errors/cliError.js";
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
 import { createIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
 import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
 import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
-import { parseRepeatable } from "./taskIntegrationCommands.js";
-import { taskLocalActor } from "./taskActor.js";
+import { taskLocalActor } from "../task/taskAuthority.js";
 export async function runTaskUpstreamCommand(args, store, home, options = {}) {
     const [command, ...rest] = args;
     if (command === "integrate")
@@ -15,7 +15,7 @@ export async function runTaskUpstreamCommand(args, store, home, options = {}) {
         : `Unknown command: task upstream ${command}`);
 }
 async function integrateUpstream(args, store, home, options) {
-    const usage = "Task upstream integrate usage: yui task upstream integrate <task> (--latest|--project <project>) [--check <command> ...].";
+    const usage = "Task upstream integrate usage: yui task upstream integrate <task> (--latest|--project <project>) [--check <command> ...] [--rerun-checks].";
     let latest = false;
     const normalized = [];
     for (const arg of args) {
@@ -29,7 +29,7 @@ async function integrateUpstream(args, store, home, options) {
             ? ["--project", arg.slice("--project=".length)]
             : [arg]));
     }
-    const parsed = parseRepeatable(normalized, new Set(["--check"]), new Set(["--project"]), usage);
+    const parsed = parseRepeatable(normalized, new Set(["--check"]), new Set(["--project"]), usage, new Set(["--rerun-checks"]));
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
     const taskId = parsed.positionals[0];
@@ -59,7 +59,7 @@ async function integrateUpstream(args, store, home, options) {
     if (workspace === null || workspace.owner.type !== "task") {
         throw usageError(`Task has no authoritative main clone: ${task.id}.`);
     }
-    const service = new GitIntegrationService(store.rootDirectory(), store, git, now);
+    const service = new GitIntegrationService(store.rootDirectory(), store, git, now, options.environment, undefined, options.jobPort);
     const results = [];
     for (const binding of task.projectBindings) {
         if (projectRef !== undefined && binding.projectId !== projectRef)
@@ -99,20 +99,31 @@ async function integrateUpstream(args, store, home, options) {
                     taskBaseCommit: binding.baseCommit,
                     strategy: "rebase"
                 },
-                checkCommands: parsed.many.get("--check") ?? []
+                checkCommands: parsed.many.get("--check") ?? [],
+                rerunChecks: parsed.one.has("--rerun-checks")
             }, now());
             tx.saveIntegrationAttempt(task.id, created);
             return created;
         });
         const result = await service.integrate(task.id, attempt.id);
         results.push(result);
-        if (result.status !== "committed")
+        // Each Project has an independent candidate and Job. --latest admits all
+        // requested Projects, then the Agent continues the returned exact attempts.
+        if (result.status !== "committed" && result.status !== "checks-running")
             break;
     }
     if (projectRef !== undefined && results.length === 0) {
         throw usageError(`Task Project not found: ${task.id}/${projectRef}.`);
     }
-    const lines = results.map(({ attempt, status }) => (`  ${attempt.projectId}: ${attempt.beforeCommit.slice(0, 12)} -> ${(attempt.afterCommit ?? attempt.candidateCommit ?? attempt.beforeCommit).slice(0, 12)} (${status})`));
+    const lines = results.flatMap(result => {
+        const { attempt, status } = result;
+        return [
+            `  ${attempt.id} ${attempt.projectId}: ${attempt.beforeCommit.slice(0, 12)} -> ${(attempt.afterCommit ?? attempt.candidateCommit ?? attempt.beforeCommit).slice(0, 12)} (${status})`,
+            ...(status === "checks-running" ? [
+                `    Job ${result.job.id}; continue with yui task integration continue ${task.id}/${attempt.id}`
+            ] : [])
+        ];
+    });
     return {
         output: `Upstream Integration results for Task ${task.id}:\n${lines.join("\n")}\n`,
         data: { taskId: task.id, integrations: results }

package/dist/commands/workflowCommands.js

@@ -103,7 +103,12 @@ export async function runWorkflowCommandAsync(args, store, options) {
         // failure so the caller knows this path was compromised.
         if (typeof store.rootDirectory === "function") {
             const auditStore = openConfiguredTaskStore(store.rootDirectory());
-            recordTaskEvent(auditStore, taskId, "release-workflow.run", eventPayload, eventNow);
+            try {
+                recordTaskEvent(auditStore, taskId, "release-workflow.run", eventPayload, eventNow);
+            }
+            finally {
+                auditStore.close();
+            }
         }
         throw error;
     }

package/dist/completion/completionInstaller.js

@@ -3,9 +3,9 @@ import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync,
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { dataError } from "../errors/cliError.js";
 import { activationBlock, activationEnd, activationIsAutomatic, activationStart, completionMarker, managedCompletionScript } from "./completionState.js";
-export function installCompletion(store, shell, installation, env, identity, activate) {
+export function installCompletion(store, shell, installation, env, activate) {
     validateInstallation(installation);
-    writeManagedScript(shell, installation.scriptPath, identity);
+    writeManagedScript(shell, installation.scriptPath);
     store.transaction((tx) => {
         const config = tx.getConfig();
         tx.saveConfig({
@@ -16,20 +16,20 @@ export function installCompletion(store, shell, installation, env, identity, act
             }
         });
     });
-    if (!activationIsAutomatic(shell, installation, env, identity) && activate) {
-        writeActivationBlock(shell, installation, identity);
+    if (!activationIsAutomatic(shell, installation, env) && activate) {
+        writeActivationBlock(shell, installation);
     }
 }
-export function uninstallCompletion(store, shell, identity) {
+export function uninstallCompletion(store, shell) {
     store.transaction((tx) => {
         const config = tx.getConfig();
         const installation = config.completionInstallations?.[shell];
         if (installation === undefined)
             return;
-        assertManagedScriptRemovable(shell, installation.scriptPath, identity);
-        assertActivationRemovable(shell, installation, identity);
-        removeManagedScript(shell, installation.scriptPath, identity);
-        removeActivationBlock(shell, installation, identity);
+        assertManagedScriptRemovable(shell, installation.scriptPath);
+        assertActivationRemovable(shell, installation);
+        removeManagedScript(shell, installation.scriptPath);
+        removeActivationBlock(shell, installation);
         const installations = { ...config.completionInstallations };
         delete installations[shell];
         if (Object.keys(installations).length > 0) {
@@ -40,17 +40,17 @@ export function uninstallCompletion(store, shell, identity) {
         tx.saveConfig(withoutInstallations);
     });
 }
-function assertManagedScriptRemovable(shell, path, identity) {
+function assertManagedScriptRemovable(shell, path) {
     if (!existsSync(path))
         return;
     const stat = lstatSync(path);
     if (!stat.isFile()
         || stat.isSymbolicLink()
-        || !readFileSync(path, "utf8").startsWith(completionMarker(shell, identity))) {
+        || !readFileSync(path, "utf8").startsWith(completionMarker(shell))) {
         throw dataError(`Refusing to remove unmanaged completion script: ${path}`);
     }
 }
-function assertActivationRemovable(shell, installation, identity) {
+function assertActivationRemovable(shell, installation) {
     const path = installation.activationPath;
     if (!existsSync(path))
         return;
@@ -59,25 +59,25 @@ function assertActivationRemovable(shell, installation, identity) {
         throw dataError(`Refusing to modify unsafe activation file: ${path}`);
     }
     const contents = readFileSync(path, "utf8");
-    const starts = occurrences(contents, activationStart(shell, identity));
-    const ends = occurrences(contents, activationEnd(shell, identity));
+    const starts = occurrences(contents, activationStart(shell));
+    const ends = occurrences(contents, activationEnd(shell));
     if (starts !== ends || starts > 1) {
         throw dataError(`Refusing to remove ambiguous Yui activation block: ${path}`);
     }
 }
-function writeManagedScript(shell, path, identity) {
+function writeManagedScript(shell, path) {
     if (existsSync(path)) {
         const stat = lstatSync(path);
         if (!stat.isFile() || stat.isSymbolicLink()) {
             throw dataError(`Refusing to overwrite unsafe completion script: ${path}`);
         }
-        if (!readFileSync(path, "utf8").startsWith(completionMarker(shell, identity))) {
+        if (!readFileSync(path, "utf8").startsWith(completionMarker(shell))) {
             throw dataError(`Refusing to overwrite unmanaged completion script: ${path}`);
         }
     }
-    writeAtomic(path, managedCompletionScript(shell, identity), 0o644);
+    writeAtomic(path, managedCompletionScript(shell), 0o644);
 }
-function writeActivationBlock(shell, installation, identity) {
+function writeActivationBlock(shell, installation) {
     const path = installation.activationPath;
     let contents = "";
     let mode = 0o644;
@@ -89,31 +89,31 @@ function writeActivationBlock(shell, installation, identity) {
         contents = readFileSync(path, "utf8");
         mode = stat.mode & 0o777;
     }
-    const start = activationStart(shell, identity);
-    const end = activationEnd(shell, identity);
+    const start = activationStart(shell);
+    const end = activationEnd(shell);
     const starts = occurrences(contents, start);
     const ends = occurrences(contents, end);
     if (starts > 1 || ends > 1 || starts !== ends) {
         throw dataError(`Refusing to modify ambiguous Yui activation block: ${path}`);
     }
-    const block = activationBlock(shell, installation, identity);
+    const block = activationBlock(shell, installation);
     const next = starts === 1
         ? replaceManagedBlock(contents, start, end, block)
         : `${contents}${contents.length === 0 || contents.endsWith("\n") ? "" : "\n"}${block}\n`;
     writeAtomic(path, next, mode);
 }
-function removeManagedScript(shell, path, identity) {
+function removeManagedScript(shell, path) {
     if (!existsSync(path))
         return;
     const stat = lstatSync(path);
     if (!stat.isFile()
         || stat.isSymbolicLink()
-        || !readFileSync(path, "utf8").startsWith(completionMarker(shell, identity))) {
+        || !readFileSync(path, "utf8").startsWith(completionMarker(shell))) {
         throw dataError(`Refusing to remove unmanaged completion script: ${path}`);
     }
     rmSync(path);
 }
-function removeActivationBlock(shell, installation, identity) {
+function removeActivationBlock(shell, installation) {
     const path = installation.activationPath;
     if (!existsSync(path))
         return;
@@ -122,8 +122,8 @@ function removeActivationBlock(shell, installation, identity) {
         throw dataError(`Refusing to modify unsafe activation file: ${path}`);
     }
     const contents = readFileSync(path, "utf8");
-    const start = activationStart(shell, identity);
-    const end = activationEnd(shell, identity);
+    const start = activationStart(shell);
+    const end = activationEnd(shell);
     const starts = occurrences(contents, start);
     const ends = occurrences(contents, end);
     if (starts !== ends || starts > 1) {

package/dist/completion/completionState.js

@@ -10,14 +10,14 @@ export function currentCompletionShell(env) {
         ? value
         : undefined;
 }
-export function suggestedCompletionInstallation(shell, env, identity) {
+export function suggestedCompletionInstallation(shell, env) {
     const home = absoluteEnvRoot("HOME", env.HOME);
     if (shell === "bash") {
         const data = env.XDG_DATA_HOME === undefined
             ? join(home, ".local", "share")
             : absoluteEnvRoot("XDG_DATA_HOME", env.XDG_DATA_HOME);
         return {
-            scriptPath: join(data, "bash-completion", "completions", identity),
+            scriptPath: join(data, "bash-completion", "completions", "yui"),
             activationPath: join(home, ".bashrc")
         };
     }
@@ -26,7 +26,7 @@ export function suggestedCompletionInstallation(shell, env, identity) {
             ? home
             : absoluteEnvRoot("ZDOTDIR", env.ZDOTDIR);
         return {
-            scriptPath: join(zshRoot, ".zfunc", `_${identity}`),
+            scriptPath: join(zshRoot, ".zfunc", "_yui"),
             activationPath: join(zshRoot, ".zshrc")
         };
     }
@@ -34,11 +34,11 @@ export function suggestedCompletionInstallation(shell, env, identity) {
         ? join(home, ".config")
         : absoluteEnvRoot("XDG_CONFIG_HOME", env.XDG_CONFIG_HOME);
     return {
-        scriptPath: join(config, "fish", "completions", `${identity}.fish`),
+        scriptPath: join(config, "fish", "completions", "yui.fish"),
         activationPath: join(config, "fish", "config.fish")
     };
 }
-export function inspectCompletionStates(config, env, identity) {
+export function inspectCompletionStates(config, env) {
     const current = currentCompletionShell(env);
     return COMPLETION_SHELLS.map((shell) => {
         const installation = config.completionInstallations?.[shell];
@@ -50,8 +50,8 @@ export function inspectCompletionStates(config, env, identity) {
                 current: shell === current
             };
         }
-        const installed = completionScriptIsCurrent(shell, installation, identity)
-            && completionActivationIsCurrent(shell, installation, env, identity);
+        const installed = completionScriptIsCurrent(shell, installation)
+            && completionActivationIsCurrent(shell, installation, env);
         return {
             shell,
             status: installed ? "Installed" : "Needs repair",
@@ -78,46 +78,46 @@ export function renderCompletionStateTable(states, width = defaultTableWidth())
         state.installation?.scriptPath ?? ""
     ]), width);
 }
-export function managedCompletionScript(shell, identity) {
-    return `${completionMarker(shell, identity)}\n${renderCompletion(shell, identity)}`;
+export function managedCompletionScript(shell) {
+    return `${completionMarker(shell)}\n${renderCompletion(shell)}`;
 }
-export function completionMarker(shell, identity) {
-    return `# yui-completion: managed shell=${shell} identity=${identity} format=1`;
+export function completionMarker(shell) {
+    return `# yui-completion: managed shell=${shell} identity=yui format=1`;
 }
-export function activationBlock(shell, installation, identity) {
-    const start = activationStart(shell, identity);
-    const end = activationEnd(shell, identity);
+export function activationBlock(shell, installation) {
+    const start = activationStart(shell);
+    const end = activationEnd(shell);
     const source = `source ${shellQuote(installation.scriptPath)}`;
     const functionName = basename(installation.scriptPath);
     const body = shell === "zsh"
-        ? `fpath=(${shellQuote(dirname(installation.scriptPath))} $fpath)\nautoload -Uz compinit\n(( $+functions[compdef] )) || compinit\nautoload -Uz -- ${shellQuote(functionName)}\ncompdef ${shellQuote(functionName)} ${shellQuote(identity)}`
+        ? `fpath=(${shellQuote(dirname(installation.scriptPath))} $fpath)\nautoload -Uz compinit\n(( $+functions[compdef] )) || compinit\nautoload -Uz -- ${shellQuote(functionName)}\ncompdef ${shellQuote(functionName)} 'yui'`
         : source;
     return `${start}\n${body}\n${end}`;
 }
-export function activationStart(shell, identity) {
-    return `# >>> yui completion shell=${shell} identity=${identity} >>>`;
+export function activationStart(shell) {
+    return `# >>> yui completion shell=${shell} identity=yui >>>`;
 }
-export function activationEnd(shell, identity) {
-    return `# <<< yui completion shell=${shell} identity=${identity} <<<`;
+export function activationEnd(shell) {
+    return `# <<< yui completion shell=${shell} identity=yui <<<`;
 }
-export function activationIsAutomatic(shell, installation, env, identity) {
+export function activationIsAutomatic(shell, installation, env) {
     return shell === "fish"
-        && installation.scriptPath === suggestedCompletionInstallation(shell, env, identity).scriptPath;
+        && installation.scriptPath === suggestedCompletionInstallation(shell, env).scriptPath;
 }
 export function shellQuote(value) {
     return `'${value.replaceAll("'", "'\\''")}'`;
 }
-export function completionScriptIsCurrent(shell, installation, identity) {
+export function completionScriptIsCurrent(shell, installation) {
     return safeRegularFile(installation.scriptPath)
-        && readFileSync(installation.scriptPath, "utf8") === managedCompletionScript(shell, identity);
+        && readFileSync(installation.scriptPath, "utf8") === managedCompletionScript(shell);
 }
-export function completionActivationIsCurrent(shell, installation, env, identity) {
-    if (activationIsAutomatic(shell, installation, env, identity))
+export function completionActivationIsCurrent(shell, installation, env) {
+    if (activationIsAutomatic(shell, installation, env))
         return true;
     if (!safeRegularFile(installation.activationPath))
         return false;
     const contents = readFileSync(installation.activationPath, "utf8");
-    const block = activationBlock(shell, installation, identity);
+    const block = activationBlock(shell, installation);
     return contents.split(block).length === 2;
 }
 function safeRegularFile(path) {

package/dist/completion/fileCompletionManager.js

@@ -4,21 +4,19 @@ import { COMPLETION_SHELLS, completionActivationIsCurrent, completionScriptIsCur
 export class FileCompletionManager {
     #store;
     #env;
-    #identity;
-    constructor(store, env, identity) {
+    constructor(store, env) {
         this.#store = store;
         this.#env = { ...env };
-        this.#identity = identity;
     }
     inspect() {
         const config = this.#store.getConfig();
         const currentShell = currentCompletionShell(this.#env);
         const states = COMPLETION_SHELLS.map((shell) => {
-            const suggested = suggestedCompletionInstallation(shell, this.#env, this.#identity);
+            const suggested = suggestedCompletionInstallation(shell, this.#env);
             const stored = config.completionInstallations?.[shell];
             const installation = stored ?? suggested;
-            const scriptCurrent = completionScriptIsCurrent(shell, installation, this.#identity);
-            const activationCurrent = completionActivationIsCurrent(shell, installation, this.#env, this.#identity);
+            const scriptCurrent = completionScriptIsCurrent(shell, installation);
+            const activationCurrent = completionActivationIsCurrent(shell, installation, this.#env);
             const status = scriptCurrent && activationCurrent
                 ? "Installed"
                 : stored === undefined ? "Not installed" : "Needs repair";
@@ -37,15 +35,12 @@ export class FileCompletionManager {
             });
         });
         return Object.freeze({
-            identity: this.#identity,
+            identity: "yui",
             ...(currentShell === undefined ? {} : { currentShell }),
             states: Object.freeze(states)
         });
     }
     install(request) {
-        installCompletion(this.#store, request.shell, request.installation, this.#env, this.#identity, request.activate);
+        installCompletion(this.#store, request.shell, request.installation, this.#env, request.activate);
     }
 }
-export function resolveCliIdentity(env) {
-    return env.YUI_CLI_NAME === "yui-dev" ? "yui-dev" : "yui";
-}

package/dist/config/configCatalog.js

@@ -14,8 +14,6 @@ export const CONFIG_DEFINITIONS = Object.freeze([
     { key: "runtime-health", domain: "runtime", property: "runtimeHealth", label: "Runtime health thresholds", summary: "Quiet, checkpoint-overdue, and read-only diagnostic thresholds in seconds; values must be strictly increasing (defaults: 300/900/1800).", takesEffect: "CLI and Web projections immediately; scheduler diagnostics after the Controller restarts." },
     { 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-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." },

package/dist/config/timeZone.js

@@ -0,0 +1,14 @@
+export const DEFAULT_TIME_ZONE = "Asia/Shanghai";
+export function resolveTimeZone(value) {
+    const timeZone = value ?? DEFAULT_TIME_ZONE;
+    if (typeof timeZone !== "string" || timeZone.trim() !== timeZone || timeZone.length === 0) {
+        throw new TypeError("timeZone must be a valid IANA timezone.");
+    }
+    try {
+        new Intl.DateTimeFormat("en", { timeZone }).format(0);
+    }
+    catch {
+        throw new TypeError("timeZone must be a valid IANA timezone.");
+    }
+    return timeZone;
+}

package/dist/config/yuiConfig.js

@@ -49,31 +49,6 @@ export function reconciliationIntervalMilliseconds(value) {
     }
     return seconds * 1_000;
 }
-/**
- * Issue 07 (Leader convergence) feature mode. `display` only shows the
- * read-only next-action decision support; `warn` additionally reports
- * duplicate deliveries and semantic-budget warnings; `enforce` hard-blocks
- * only exact duplicates, while semantic-budget exhaustion remains a warning
- * because it must not override Leader judgment. The mode is additive and
- * optional — Homes without it keep the `display` default, so no config
- * migration is required.
- */
-export const LEADER_NEXT_ACTION_MODES = ["display", "warn", "enforce"];
-export const DEFAULT_LEADER_NEXT_ACTION_MODE = "display";
-export function resolveLeaderNextActionMode(value) {
-    if (value === undefined || value === null)
-        return DEFAULT_LEADER_NEXT_ACTION_MODE;
-    if (typeof value !== "string") {
-        throw new TypeError("leaderNextActionMode must be display, warn, or enforce.");
-    }
-    const normalized = value.trim().toLowerCase();
-    if (normalized.length === 0)
-        return DEFAULT_LEADER_NEXT_ACTION_MODE;
-    if (!LEADER_NEXT_ACTION_MODES.includes(normalized)) {
-        throw new TypeError("leaderNextActionMode must be display, warn, or enforce.");
-    }
-    return normalized;
-}
 // ── Executable paths ──────────────────────────────────────────────────────
 export function resolveTmuxBin(value) {
     if (value === undefined || value === null)
@@ -115,7 +90,6 @@ 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_RUNS = 3;
 export const DEFAULT_TMUX_HISTORY_LIMIT = 100_000;
 export function resolveRuntimeHealth(configured) {
     if (configured === undefined || configured === null)
@@ -141,9 +115,6 @@ export function resolveAgentLaunchInactivityTimeoutSeconds(value) {
 export function resolveDeliveryTimeoutSeconds(value) {
     return resolveBoundedPositiveInteger(value, DEFAULT_DELIVERY_TIMEOUT_SECONDS, 5, 600, "deliveryTimeoutSeconds");
 }
-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/runContextPack.js

@@ -278,8 +278,7 @@ export function buildRunContextPack(store, taskId, runId) {
 }
 /** Reads the Task's current in-flight execution, outside the frozen contract. */
 function readLiveTaskState(store, taskId) {
-    const activeRuns = store.listRuns(taskId)
-        .filter((run) => run.status === "active")
+    const activeRuns = store.listActiveRuns(taskId)
         .map((run) => Object.freeze({
         runId: run.id,
         roleName: run.roleName,
@@ -288,7 +287,7 @@ function readLiveTaskState(store, taskId) {
         ...(run.reviewRoundId === undefined ? {} : { reviewRoundId: run.reviewRoundId })
     }));
     const activeTaskReviews = store.listReviewRounds(taskId)
-        .filter((round) => ((round.scope ?? "work-item") === "task"
+        .filter((round) => (round.scope === "task"
         && (round.status === "pending" || round.status === "running")))
         .map((round) => Object.freeze({
         reviewRoundId: round.id,