@zq-silk/yui 0.8.7 → 0.8.9

package/dist/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
@@ -48,7 +49,7 @@ import { runWorkflowCommandAsync } from "./commands/workflowCommands.js";
 import { createUpdatePorts } from "./cli/updatePorts.js";
 import { createReleaseWorkflowPorts } from "./release/releaseWorkflowPorts.js";
 import { acquireHandoverLock, readRuntimeIdentity } from "./release/runtimeRelease.js";
-import { renderReleaseActivateResult, renderReleaseInstallResult, renderReleaseList, runReleaseActivate, runReleaseInstall, runReleaseList } from "./commands/releaseCommands.js";
+import { renderReleaseActivateResult, renderReleaseInstallResult, renderReleaseList, resolveReleaseActivationDriver, runReleaseActivate, runReleaseInstall, runReleaseList } from "./commands/releaseCommands.js";
 import { reconcileTaskRemoteBaselines, verifyTaskCompletionPublishedTree } from "./commands/taskCompletionGate.js";
 import { runTaskBaseStatusCommand } from "./commands/taskBaseCommands.js";
 import { assertTaskBaseFreshnessForCompletion, inspectTaskBaseFreshness } from "./repository/taskBaseFreshness.js";
@@ -112,6 +113,22 @@ void main().catch((error) => {
     process.exitCode = 5;
 });
 export async function main() {
+    const delegatedDriver = explicitReleaseActivationDriver();
+    if (delegatedDriver !== null) {
+        const delegated = spawnSync(process.execPath, [delegatedDriver, ...process.argv.slice(2)], {
+            cwd: process.cwd(),
+            env: process.env,
+            stdio: "inherit"
+        });
+        if (delegated.error !== undefined) {
+            throw runtimeError(`Target release activation driver could not start: ${delegated.error.message}`);
+        }
+        if (delegated.signal !== null) {
+            throw runtimeError(`Target release activation driver stopped by signal ${delegated.signal}.`);
+        }
+        process.exitCode = delegated.status ?? 5;
+        return;
+    }
     const { contract: taskFinalReviewContract, verifiedStore, controlPlane: exactCurrentControlPlane } = await preflightManagedTaskControlPlane();
     if (args.length === 0) {
         emit(renderCommandHelp((await import("./cli/commandCatalog.js")).ROOT_COMMAND, VERSION));
@@ -1360,6 +1377,15 @@ export async function main() {
     }
     throw usageError(`Command is not connected to the restored FileTaskStore framework yet: ${resolved[0]}.`, renderCommandHelp(invocation.node, VERSION));
 }
+function explicitReleaseActivationDriver() {
+    if (args.length !== 3
+        || args[0] !== "release"
+        || args[1] !== "activate"
+        || args[2].startsWith("-")) {
+        return null;
+    }
+    return resolveReleaseActivationDriver(resolveYuiHome(process.env), args[2], fileURLToPath(import.meta.url));
+}
 async function preflightManagedTaskControlPlane() {
     if (exactControlInvocation.error !== undefined) {
         throw new Error(exactControlInvocation.error);

package/dist/commands/releaseCommands.js

@@ -8,7 +8,7 @@ import { join, resolve } from "node:path";
 import { callController, ControllerClientError } from "../core/controllerClient.js";
 import { readLinuxProcessStartIdentity } from "../controller/domainIdentity.js";
 import { activateRelease } from "../release/releaseHandover.js";
-import { assertReleaseIsNotWorktreeOrLinked, readActiveReleasePointer, readReleaseManifest, releasesDirectory, releaseDirectoryFor, verifyReleaseIntegrity, writeSmokeReceipt } from "../release/runtimeRelease.js";
+import { assertReleaseIsNotWorktreeOrLinked, detectRunningRelease, readActiveReleasePointer, readReleaseManifest, readSmokeReceipt, releasesDirectory, releaseDirectoryFor, verifyReleaseIntegrity, writeSmokeReceipt } from "../release/runtimeRelease.js";
 /**
  * Installs a runtime package directory into the Home's immutable release
  * tree. The source must carry a release manifest, must not be a Git worktree
@@ -123,7 +123,7 @@ export function runReleaseList(home) {
                     version: manifest.version,
                     buildId: manifest.buildId,
                     packageDigest: manifest.packageDigest,
-                    smoke: existsSync(join(releaseDir, "smoke-receipt.json"))
+                    smoke: hasMatchingSmokeReceipt(releaseDir, manifest)
                 };
             }
             catch {
@@ -142,6 +142,8 @@ export function runReleaseList(home) {
 /** Resolves an installed release by directory name or build ID. */
 export function resolveInstalledRelease(home, releaseId) {
     const directory = releasesDirectory(home);
+    if (!existsSync(directory))
+        return null;
     for (const entry of readdirSync(directory, { withFileTypes: true })) {
         if (!entry.isDirectory())
             continue;
@@ -156,18 +158,45 @@ export function resolveInstalledRelease(home, releaseId) {
                     + "Reinstall it with `yui release install <source-dir>` before activating.", { cause: error });
             }
         }
+        const releaseDir = join(directory, entry.name);
+        let manifest;
         try {
-            const manifest = readReleaseManifest(join(directory, entry.name));
-            if (manifest.buildId === releaseId) {
-                return { releaseDir: join(directory, entry.name), manifest };
-            }
+            manifest = readReleaseManifest(releaseDir);
         }
         catch {
             continue;
         }
+        if (manifest.buildId !== releaseId)
+            continue;
+        try {
+            return { releaseDir, manifest: verifyReleaseIntegrity(releaseDir) };
+        }
+        catch (error) {
+            throw new Error(`Release ${releaseId} failed integrity verification and may have drifted: `
+                + `${error instanceof Error ? error.message : String(error)}. `
+                + "Reinstall it with `yui release install <source-dir>` before activating.", { cause: error });
+        }
     }
     return null;
 }
+/**
+ * Selects the verified target release CLI as the activation driver. Ordinary
+ * commands remain on the globally installed CLI; only an explicit target
+ * activation crosses into the target package so its handover deadlines and
+ * protocol own the complete operation.
+ */
+export function resolveReleaseActivationDriver(home, releaseId, currentCliPath) {
+    const resolved = resolveInstalledRelease(home, releaseId);
+    if (resolved === null)
+        return null;
+    if (!hasMatchingSmokeReceipt(resolved.releaseDir, resolved.manifest))
+        return null;
+    const running = detectRunningRelease(currentCliPath);
+    if (running !== null && resolve(running.releaseDir) === resolve(resolved.releaseDir)) {
+        return null;
+    }
+    return join(resolved.releaseDir, "dist", "cli.js");
+}
 /** Runs the atomic Controller handover for one installed release. */
 export async function runReleaseActivate(home, releaseId, options = {}) {
     let resolved;
@@ -192,11 +221,11 @@ export async function runReleaseActivate(home, releaseId, options = {}) {
             recoverable: true
         };
     }
-    if (!existsSync(join(resolved.releaseDir, "smoke-receipt.json"))) {
+    if (!hasMatchingSmokeReceipt(resolved.releaseDir, resolved.manifest)) {
         return {
             outcome: "aborted",
             phase: "resolve",
-            message: `Release has no smoke receipt: ${releaseId}.`,
+            message: `Release has no matching smoke receipt: ${releaseId}.`,
             action: "Reinstall the release; the smoke receipt is written at install time.",
             recoverable: true
         };
@@ -217,6 +246,13 @@ export async function runReleaseActivate(home, releaseId, options = {}) {
             : { dualOwnerGraceMs: options.dualOwnerGraceMs })
     });
 }
+function hasMatchingSmokeReceipt(releaseDir, manifest) {
+    const receipt = readSmokeReceipt(releaseDir);
+    return receipt !== null
+        && receipt.version === manifest.version
+        && receipt.buildId === manifest.buildId
+        && receipt.packageDigest === manifest.packageDigest;
+}
 /** Renders the install result as concise CLI text. */
 export function renderReleaseInstallResult(result) {
     switch (result.outcome) {

package/dist/observability/runtimeIdentity.js

@@ -79,10 +79,21 @@ export function createProductionRuntimeIdentityPorts(packageRoot, entryPath, env
 }
 function readGitHead(packageRoot) {
     try {
-        const result = spawnSync("git", ["-C", packageRoot, "rev-parse", "HEAD"], { encoding: "utf8", timeout: 1_500, stdio: ["ignore", "pipe", "ignore"] });
-        if (result.status !== 0)
+        const resolvedPackageRoot = realpathSync(packageRoot);
+        const rootResult = spawnSync("git", ["-C", resolvedPackageRoot, "rev-parse", "--show-toplevel"], { encoding: "utf8", timeout: 1_500, stdio: ["ignore", "pipe", "ignore"] });
+        if (rootResult.status !== 0)
             return null;
-        const head = result.stdout.trim();
+        const repositoryRoot = realpathSync(rootResult.stdout.trim());
+        // `git -C` searches parent directories. A globally installed package may
+        // therefore appear to belong to an unrelated repository that happens to
+        // contain the package manager directory (for example ~/.nvm). Only the
+        // package's own checkout is valid source identity evidence.
+        if (repositoryRoot !== resolvedPackageRoot)
+            return null;
+        const headResult = spawnSync("git", ["-C", resolvedPackageRoot, "rev-parse", "HEAD"], { encoding: "utf8", timeout: 1_500, stdio: ["ignore", "pipe", "ignore"] });
+        if (headResult.status !== 0)
+            return null;
+        const head = headResult.stdout.trim();
         return /^[a-f0-9]{7,40}$/u.test(head) ? head : null;
     }
     catch {

package/dist/release/releaseHandover.js

@@ -135,8 +135,8 @@ async function activateLocked(ports, locked) {
         };
     }
     // 6) Switch the active release pointer. This is the atomic commit point:
-    // after it succeeds, the stable launcher and new Sessions resolve the new
-    // release.
+    // after it succeeds, Controller lifecycle operations resolve the new
+    // release. The ordinary CLI and managed Session wrappers stay on `yui`.
     const pointer = Object.freeze({
         schemaVersion: 1,
         releaseId,

package/dist/release/runtimeRelease.js

@@ -4,9 +4,10 @@
  *
  * A release is a self-contained, content-addressed runtime package unpacked
  * below `runtime/releases/<version>-<package-sha256>/`. The Home's active
- * release pointer (`runtime/active-release.json`) names exactly one release;
- * the stable launcher shim resolves the CLI through that pointer instead of
- * symlinking a development checkout.
+ * release pointer (`runtime/active-release.json`) names exactly one Controller
+ * release. The ordinary CLI remains the globally installed package; only an
+ * explicit target activation delegates to the verified target release CLI so
+ * that release owns its handover protocol and deadlines.
  *
  * The Controller writes its provenance to `runtime/runtime-identity.json` on
  * every start, and a versioned handover fence (`runtime/handover-fence.json`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "0.8.7",
+  "version": "0.8.9",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,