@younndai/lyt 0.13.4 → 0.20.0

package/dist/commands/update.js

@@ -14,77 +14,912 @@
  * limitations under the License.
  */
 import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
-import { Command } from "commander";
-import { checkCurrency, CURRENCY_DIST_TAG, CURRENCY_PACKAGE, formatCurrencyLine, resolveUpdateAction, } from "@younndai/lyt-vault";
+import { homedir } from "node:os";
+import { Command, InvalidArgumentError } from "commander";
+import { checkCurrency, formatCurrencyLine, isUpdateChannel, readUpdateChannel, resolveUpdateAction, writeUpdateChannel, } from "@younndai/lyt-vault";
+import { canonicalJson, digestCanonical, applyExactUpdatePlanV1, parseUpdatePlanV1, prepareUpdatePlanV1, UPDATE_PLAN_PACKAGES, } from "../install/update-plan.js";
+import { prepareInstallReconcilePlanV1, } from "../install/reconcile-engine.js";
+import { beginUpdateOperationV1, defaultUpdateOperationRoot, readUpdateOperationPlanV1, } from "../install/update-operation.js";
+import { inspectTargetTarballBytes, materializeTargetProviders, providersFromUpdatePlan, stageTargetArtifactsV1, verifyInstalledPayloadV1, writeInstalledStateAnchorV1, } from "../install/target-artifacts.js";
+import { detectInstalledRuntimes } from "@younndai/lyt-vault";
+export function configureUpdateChannel(channel, write = writeUpdateChannel) {
+    write(channel);
+    return Object.freeze({
+        schema_id: "lyt.update-channel-configured",
+        schema_version: Object.freeze({ major: 1, minor: 0 }),
+        channel,
+        persisted: true,
+        next_action: "lyt update --check --json",
+    });
+}
+function parseChannel(value) {
+    if (isUpdateChannel(value))
+        return value;
+    throw new InvalidArgumentError("--channel must be alpha or latest");
+}
+function readMetaVersion() {
+    return createRequire(import.meta.url)("../package.json").version;
+}
+export function resolveConfiguredChannel(requested, persisted, opts) {
+    if (requested !== undefined) {
+        if (persisted !== null && requested !== persisted && opts.switchChannel !== true) {
+            return {
+                channel: null,
+                source: "explicit",
+                refusal: "channel-switch-requires-explicit",
+                nextAction: `lyt update --channel ${requested} --switch-channel`,
+            };
+        }
+        return { channel: requested, source: "explicit" };
+    }
+    if (persisted !== null)
+        return { channel: persisted, source: "persisted" };
+    if (opts.interactive && opts.selectedInteractive !== undefined) {
+        if (opts.selectedInteractive !== null)
+            return { channel: opts.selectedInteractive, source: "interactive" };
+        return {
+            channel: null,
+            source: "unconfigured",
+            refusal: "channel-unconfigured",
+            nextAction: "lyt update --channel alpha",
+        };
+    }
+    return {
+        channel: null,
+        source: "unconfigured",
+        refusal: "channel-unconfigured",
+        nextAction: "lyt update --channel alpha",
+    };
+}
+export function parseReconcileReceipt(raw, updatePlan) {
+    try {
+        const value = JSON.parse(raw);
+        const receipt = value.receipt;
+        if (value.schema_id !== "lyt.install-reconcile-result" ||
+            value.schema_version?.major !== 1 ||
+            value.schema_version?.minor !== 0 ||
+            typeof value.operation_id !== "string" ||
+            typeof value.attempt_id !== "string" ||
+            typeof value.status !== "string" ||
+            typeof value.success !== "boolean" ||
+            value.success !== true ||
+            (value.status !== "success" && value.status !== "no-op") ||
+            !Number.isInteger(value.mutations) ||
+            (value.mutations ?? -1) < 0 ||
+            !Array.isArray(value.completed) ||
+            !Array.isArray(value.pending) ||
+            !Array.isArray(value.refused) ||
+            value.pending.length !== 0 ||
+            value.refused.length !== 0 ||
+            value.next_action !== null ||
+            !("mutations" in value) ||
+            !("next_action" in value) ||
+            receipt?.schema_id !== "lyt.receipt" ||
+            receipt.schema_version?.major !== 1 ||
+            receipt.schema_version?.minor !== 0 ||
+            receipt.operation !== "install-reconcile" ||
+            receipt.operation_id !== value.operation_id ||
+            receipt.attempt_id !== value.attempt_id ||
+            receipt.status !== value.status ||
+            !receipt.mutations ||
+            receipt.mutations.local !== value.mutations ||
+            receipt.mutations.remote !== 0 ||
+            receipt.next_action !== null) {
+            return null;
+        }
+        if (updatePlan !== undefined) {
+            const completed = [...value.completed].sort();
+            const expected = [...updatePlan.target_provider_objects].sort((a, b) => a.object_id.localeCompare(b.object_id));
+            const actual = [...(value.plan?.objects ?? [])]
+                .filter((object) => expected.some((entry) => entry.object_id === object.object_id))
+                .sort((a, b) => a.object_id.localeCompare(b.object_id));
+            if (canonicalJson(completed) !== canonicalJson(expected.map((object) => object.object_id)) ||
+                canonicalJson(actual.map((object) => ({
+                    object_id: object.object_id,
+                    expected_digest: object.expected_digest,
+                    expected_applied_digest: object.expected_applied_digest,
+                }))) !==
+                    canonicalJson(expected.map((object) => ({
+                        object_id: object.object_id,
+                        expected_digest: object.expected_digest,
+                        expected_applied_digest: object.expected_applied_digest,
+                    }))))
+                return null;
+        }
+        return receipt;
+    }
+    catch {
+        return null;
+    }
+}
 export async function runUpdateFlow(result, opts, fx) {
-    const action = resolveUpdateAction(result, { yes: opts.yes, interactive: opts.interactive });
+    const action = resolveUpdateAction(result, {
+        yes: opts.yes,
+        interactive: opts.interactive,
+        allowDowngrade: opts.allowDowngrade,
+    });
     switch (action.kind) {
-        case "offline":
+        case "channel-unconfigured":
             fx.error(action.message);
-            return { installed: false, exitCode: 0 };
+            return {
+                installed: false,
+                reconciled: false,
+                reconcileReceipt: null,
+                exitCode: 2,
+                nextAction: action.nextAction,
+            };
+        case "offline":
         case "current":
-            fx.log(action.message);
-            return { installed: false, exitCode: 0 };
+        case "ahead-of-channel":
+            (action.kind === "ahead-of-channel" ? fx.error : fx.log)(action.message);
+            return {
+                installed: false,
+                reconciled: false,
+                reconcileReceipt: null,
+                exitCode: action.kind === "ahead-of-channel" ? 2 : 0,
+            };
         case "blocked-noninteractive":
             fx.error(action.message);
-            return { installed: false, exitCode: 1 };
+            return { installed: false, reconciled: false, reconcileReceipt: null, exitCode: 1 };
         case "needs-confirm": {
-            const ok = await fx.confirm(`${action.message} [y/N] `);
-            if (!ok) {
-                fx.log("Update cancelled.");
-                return { installed: false, exitCode: 0 };
-            }
-            return finishInstall(fx);
+            return prepareAndFinishInstall(result, fx, async (plan) => fx.confirm(`${action.message} Exact target ${plan.target_version}; sealed plan ${plan.plan_digest}. [y/N] `));
         }
         case "proceed":
             fx.log(action.message);
-            return finishInstall(fx);
+            return prepareAndFinishInstall(result, fx);
+    }
+}
+async function prepareAndFinishInstall(currency, fx, confirmation) {
+    let plan;
+    try {
+        plan = parseUpdatePlanV1(await fx.preparePlan(currency));
+    }
+    catch (error) {
+        fx.error(`lyt update: could not seal the exact update plan (${String(error)}).`);
+        return { installed: false, reconciled: false, reconcileReceipt: null, exitCode: 1 };
     }
+    if (confirmation !== undefined && !(await confirmation(plan))) {
+        fx.log("Update cancelled.");
+        return {
+            installed: false,
+            reconciled: false,
+            reconcileReceipt: null,
+            exitCode: 0,
+            updatePlan: plan,
+        };
+    }
+    return finishInstall(plan, fx);
 }
-function finishInstall(fx) {
-    const status = fx.install();
+async function finishInstall(plan, fx) {
+    const alreadyInstalled = await fx.verifyInstalledPlan(plan);
+    if (!alreadyInstalled && !(await fx.revalidatePlan(plan))) {
+        fx.error("lyt update: sealed registry, package graph, or destination evidence changed; no install started.");
+        return {
+            installed: false,
+            reconciled: false,
+            reconcileReceipt: null,
+            exitCode: 1,
+            updatePlan: plan,
+        };
+    }
+    let operation;
+    try {
+        operation = await fx.beginOperation(plan);
+    }
+    catch (error) {
+        fx.error(`lyt update: could not open the durable update operation (${String(error)}).`);
+        return {
+            installed: false,
+            reconciled: false,
+            reconcileReceipt: null,
+            exitCode: 1,
+            nextAction: "lyt doctor --json",
+            updatePlan: plan,
+        };
+    }
+    if (operation === null) {
+        fx.error("lyt update: the Phase-A update receipt store is unavailable; no install started.");
+        return {
+            installed: false,
+            reconciled: false,
+            reconcileReceipt: null,
+            exitCode: 1,
+            updatePlan: plan,
+        };
+    }
+    if (operation.alreadyCompleted) {
+        fx.log(`lyt update: sealed operation ${plan.operation_id} is already complete.`);
+        return {
+            installed: true,
+            reconciled: true,
+            reconcileReceipt: null,
+            exitCode: 0,
+            updatePlan: plan,
+        };
+    }
+    let artifactPaths = [];
+    if (!alreadyInstalled) {
+        try {
+            artifactPaths = await fx.stageArtifacts(plan);
+        }
+        catch (error) {
+            fx.error(`lyt update: exact target artifacts could not be staged (${String(error)}).`);
+            return {
+                installed: false,
+                reconciled: false,
+                reconcileReceipt: null,
+                exitCode: 1,
+                nextAction: `lyt update --resume ${plan.operation_id} --yes`,
+                updatePlan: plan,
+            };
+        }
+    }
+    const status = alreadyInstalled ? 0 : fx.install(plan, artifactPaths);
     if (status !== 0) {
-        fx.error(`lyt update: \`npm i -g ${CURRENCY_PACKAGE}@${CURRENCY_DIST_TAG}\` failed (exit ${status}).`);
-        return { installed: false, exitCode: 1 };
+        fx.error(`lyt update: exact @younndai/lyt@${plan.target_version} install failed (exit ${status}).`);
+        return {
+            installed: false,
+            reconciled: false,
+            reconcileReceipt: null,
+            exitCode: 1,
+            nextAction: `lyt update --resume ${plan.operation_id} --yes`,
+            updatePlan: plan,
+        };
+    }
+    if (!(await fx.verifyInstalledPlan(plan))) {
+        fx.error("lyt update: npm returned success, but the seven exact installed versions or sealed same-registry package graph did not verify.");
+        return {
+            installed: false,
+            reconciled: false,
+            reconcileReceipt: null,
+            exitCode: 1,
+            nextAction: `lyt update --resume ${plan.operation_id} --yes`,
+            updatePlan: plan,
+        };
+    }
+    if (!(await operation.finalizeCompleted())) {
+        fx.error("lyt update: npm replacement verified, but the authoritative update receipt was not persisted.");
+        return {
+            installed: true,
+            reconciled: false,
+            reconcileReceipt: null,
+            exitCode: 1,
+            nextAction: `lyt update --resume ${plan.operation_id} --yes`,
+            updatePlan: plan,
+        };
+    }
+    const reconciliation = fx.reconcile(plan);
+    const receipt = reconciliation.exitCode === 0 ? parseReconcileReceipt(reconciliation.stdout, plan) : null;
+    if (receipt === null || (receipt.status !== "success" && receipt.status !== "no-op")) {
+        const detail = reconciliation.stderr.trim() || reconciliation.stdout.trim();
+        fx.error("lyt update: npm replacement completed, but the replacement Lyt did not return an authoritative reconciliation Receipt. " +
+            "Run `lyt install reconcile --apply --json` in a new process; start a fresh agent session before expecting managed skills or manuals to be loaded." +
+            (detail.length > 0 ? ` Detail: ${detail.slice(0, 500)}` : ""));
+        return {
+            installed: true,
+            reconciled: false,
+            reconcileReceipt: receipt,
+            exitCode: 1,
+            nextAction: "lyt install reconcile --apply --json",
+            updatePlan: plan,
+        };
+    }
+    const receiptDigest = digestCanonical(receipt);
+    if (!fx.writeInstalledAnchor(plan)) {
+        fx.error("lyt update: reconciliation succeeded, but installed-state evidence was not anchored.");
+        return {
+            installed: true,
+            reconciled: false,
+            reconcileReceipt: receipt,
+            exitCode: 1,
+            nextAction: `lyt update --resume ${plan.operation_id} --yes`,
+            updatePlan: plan,
+        };
+    }
+    if (!(await operation.recordReconciled(receiptDigest))) {
+        fx.error("lyt update: reconciliation succeeded, but its boundary evidence was not journaled.");
+        return {
+            installed: true,
+            reconciled: false,
+            reconcileReceipt: receipt,
+            exitCode: 1,
+            nextAction: `lyt update --resume ${plan.operation_id} --yes`,
+            updatePlan: plan,
+        };
+    }
+    const applied = await applyExactUpdatePlanV1(plan, {
+        alreadyCompleted: async (boundary) => operation.isBoundaryCompleted(boundary.boundary_id),
+        revalidate: async () => false,
+        apply: async () => {
+            throw new Error("update-operation-boundary-not-journaled");
+        },
+    });
+    if (applied.pending.length > 0) {
+        fx.error("lyt update: the exact update plan still has unjournaled boundaries.");
+        return {
+            installed: true,
+            reconciled: false,
+            reconcileReceipt: receipt,
+            exitCode: 1,
+            nextAction: `lyt update --resume ${plan.operation_id} --yes`,
+            updatePlan: plan,
+        };
+    }
+    fx.log(`lyt update: npm replacement completed; reconciliation Receipt ${receipt.operation_id}/${receipt.attempt_id} is authoritative. ` +
+        "Start a fresh agent session before treating injected manuals or skills as loaded.");
+    return {
+        installed: true,
+        reconciled: true,
+        reconcileReceipt: receipt,
+        exitCode: 0,
+        updatePlan: plan,
+    };
+}
+export async function resumeUpdateFlow(operationId, fx) {
+    return finishInstall(readUpdateOperationPlanV1(operationId), fx);
+}
+function resolveNpmCliPath() {
+    const candidates = [
+        process.env.npm_execpath,
+        process.env.NPM_EXECPATH,
+        join(dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js"),
+        join(dirname(dirname(process.execPath)), "node_modules", "npm", "bin", "npm-cli.js"),
+    ].filter((candidate) => typeof candidate === "string" && candidate.length > 0);
+    const found = candidates.find((candidate) => existsSync(candidate));
+    return found === undefined ? null : resolve(found);
+}
+function packageRoot(packageName) {
+    try {
+        const require = createRequire(import.meta.url);
+        let cursor = dirname(require.resolve(packageName));
+        for (let depth = 0; depth < 8; depth += 1) {
+            if (existsSync(join(cursor, "package.json")))
+                return cursor;
+            const parent = dirname(cursor);
+            if (parent === cursor)
+                break;
+            cursor = parent;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+async function fetchExactPackageGraph(plan) {
+    return Promise.all(UPDATE_PLAN_PACKAGES.map(async (name) => {
+        const url = new URL(`${encodeURIComponent(name)}/${encodeURIComponent(plan.version)}`, plan.registry);
+        const response = await fetch(url, { headers: { accept: "application/json" } });
+        if (!response.ok)
+            throw new Error(`update-plan-registry-${response.status}`);
+        const manifest = (await response.json());
+        if (manifest.version !== plan.version ||
+            typeof manifest.dist?.integrity !== "string" ||
+            typeof manifest.dist.tarball !== "string") {
+            throw new Error("update-plan-registry-manifest-invalid");
+        }
+        const dependencies = Object.keys(manifest.dependencies ?? {})
+            .filter((candidate) => UPDATE_PLAN_PACKAGES.includes(candidate))
+            .sort();
+        return Object.freeze({
+            name,
+            version: plan.version,
+            integrity: manifest.dist.integrity,
+            tarball_url: manifest.dist.tarball,
+            dependencies,
+        });
+    }));
+}
+function observeInstalledState() {
+    const packages = UPDATE_PLAN_PACKAGES.map((name) => {
+        const root = packageRoot(name);
+        if (root === null)
+            return { name, version: null, integrity: null };
+        try {
+            const manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+            return {
+                name,
+                version: typeof manifest.version === "string" ? manifest.version : null,
+                integrity: null,
+            };
+        }
+        catch {
+            return { name, version: null, integrity: null };
+        }
+    });
+    const cli = typeof process.argv[1] === "string" ? resolve(process.argv[1]) : null;
+    const bins = cli === null
+        ? []
+        : [
+            {
+                path: cli,
+                digest: existsSync(cli)
+                    ? createHash("sha256").update(readFileSync(cli)).digest("hex")
+                    : null,
+            },
+        ];
+    return { packages, bins };
+}
+export function providerDestinationsFromReconcilePlan(reconcilePlan) {
+    return reconcilePlan.objects.map((object) => ({
+        object_id: object.object_id,
+        kind: object.kind === "directory-link" ? "skill" : "manual",
+        path: object.target_path,
+        source_package: object.provider_package,
+        evidence_kind: "provider-content-digest",
+        expected_before_digest: object.observed_digest,
+        expected_after_digest: object.expected_applied_digest,
+    }));
+}
+export function targetProviderObjectsFromTargetManifests(reconcilePlan, manifests) {
+    const declared = new Map();
+    for (const manifest of manifests) {
+        for (const object of manifest.objects) {
+            const id = object.kind === "directory-link"
+                ? `skill:${object.runtime}:${object.name}`
+                : `manual:${object.runtime}`;
+            declared.set(id, object);
+        }
+    }
+    return reconcilePlan.objects.map((object) => {
+        const target = declared.get(object.object_id);
+        if (target === undefined)
+            throw new Error("update-target-provider-object-missing");
+        return {
+            object_id: object.object_id,
+            kind: object.kind,
+            provider_package: object.provider_package,
+            provider_version: object.provider_version,
+            target_path: object.target_path,
+            source_relative_path: target.kind === "directory-link" ? target.source_relative_path : null,
+            content: target.kind === "marker-file" ? target.content : null,
+            expected_digest: object.expected_digest,
+            expected_applied_digest: object.expected_applied_digest,
+            marker_begin: target.kind === "marker-file" ? target.marker_begin : null,
+            marker_end: target.kind === "marker-file" ? target.marker_end : null,
+        };
+    });
+}
+export async function prepareProductionUpdatePlan(currency) {
+    if (currency.latest === null || currency.integrity === null || currency.channel === null) {
+        throw new Error("update-plan-currency-incomplete");
+    }
+    const graph = await fetchExactPackageGraph({
+        registry: currency.registry,
+        version: currency.latest,
+    });
+    const meta = graph.find((entry) => entry.name === "@younndai/lyt");
+    if (meta?.integrity !== currency.integrity)
+        throw new Error("update-plan-currency-integrity-drift");
+    const inspected = await Promise.all(graph.map(async (fact) => {
+        const response = await fetch(fact.tarball_url);
+        if (!response.ok)
+            throw new Error(`update-target-fetch-${response.status}`);
+        return inspectTargetTarballBytes({
+            package: fact.name,
+            version: fact.version,
+            integrity: fact.integrity,
+            tarballUrl: fact.tarball_url,
+            bytes: new Uint8Array(await response.arrayBuffer()),
+        });
+    }));
+    const targetArtifacts = inspected.map((entry) => entry.artifact);
+    const manifests = inspected
+        .map((entry) => entry.provider_manifest)
+        .filter((entry) => entry !== null);
+    const extractedRoots = new Map(UPDATE_PLAN_PACKAGES.map((name) => [name, join(homedir(), "lyt", ".update-target", name)]));
+    const providers = materializeTargetProviders({
+        manifests,
+        extractedRoots,
+        homeDir: homedir(),
+        runtimes: detectInstalledRuntimes(homedir()),
+    });
+    const reconcilePlan = prepareInstallReconcilePlanV1(providers);
+    const targetProviderObjects = targetProviderObjectsFromTargetManifests(reconcilePlan, manifests);
+    const beforeState = observeInstalledState();
+    const packageDestinations = UPDATE_PLAN_PACKAGES.map((name) => {
+        const root = packageRoot(name);
+        const manifestPath = root === null ? `unresolved:${name}` : join(root, "package.json");
+        const before = root !== null && existsSync(manifestPath)
+            ? createHash("sha256").update(readFileSync(manifestPath)).digest("hex")
+            : null;
+        const artifact = targetArtifacts.find((entry) => entry.package === name);
+        return {
+            object_id: `package:${name.slice("@younndai/".length)}`,
+            kind: "package",
+            path: root ?? manifestPath,
+            source_package: name,
+            evidence_kind: "registry-version-sri",
+            expected_before_digest: before,
+            expected_after_digest: artifact.payload_digest,
+        };
+    });
+    const binDestinations = beforeState.bins.map((bin, index) => ({
+        object_id: `bin:lyt:${index}`,
+        kind: "bin",
+        path: bin.path,
+        source_package: "@younndai/lyt",
+        evidence_kind: "bounded-target-identity",
+        expected_before_digest: bin.digest,
+        expected_after_digest: digestCanonical({ kind: "bin-target", path: resolve(bin.path) }),
+    }));
+    const providerDestinations = providerDestinationsFromReconcilePlan(reconcilePlan);
+    const destinations = [...packageDestinations, ...binDestinations, ...providerDestinations];
+    const npmObjectIds = [...packageDestinations, ...binDestinations].map((entry) => entry.object_id);
+    const skillObjectIds = providerDestinations
+        .filter((entry) => entry.kind === "skill")
+        .map((entry) => entry.object_id);
+    const manualObjectIds = providerDestinations
+        .filter((entry) => entry.kind === "manual")
+        .map((entry) => entry.object_id);
+    return prepareUpdatePlanV1({
+        registryUrl: currency.registry,
+        channel: currency.channel,
+        targetVersion: currency.latest,
+        distIntegrity: currency.integrity,
+        packageGraph: graph,
+        targetArtifacts,
+        targetProviderObjects,
+        beforeState,
+        destinations,
+        boundaries: [
+            {
+                boundary_id: "npm-self-replacement",
+                kind: "npm-self-replacement",
+                object_ids: npmObjectIds,
+            },
+            ...(skillObjectIds.length > 0
+                ? [
+                    {
+                        boundary_id: "skill-leaves",
+                        kind: "skill-leaves",
+                        object_ids: skillObjectIds,
+                    },
+                ]
+                : []),
+            ...(manualObjectIds.length > 0
+                ? [
+                    {
+                        boundary_id: "agent-manuals",
+                        kind: "agent-manuals",
+                        object_ids: manualObjectIds,
+                    },
+                ]
+                : []),
+        ],
+        expectedEvidence: [
+            "registry-version-sri",
+            "package-graph",
+            "provider-content-digest",
+            "bin-target-identity",
+            "receipt-v1",
+        ],
+    });
+}
+export async function revalidateProductionUpdatePlan(plan) {
+    try {
+        const parsed = parseUpdatePlanV1(plan);
+        const graph = await fetchExactPackageGraph({
+            registry: parsed.registry_url,
+            version: parsed.target_version,
+        });
+        if (canonicalJson(graph) !== canonicalJson(parsed.package_graph))
+            return false;
+        const observed = observeInstalledState();
+        if (canonicalJson(observed) !== canonicalJson(parsed.before_state))
+            return false;
+        const currentRoots = new Map(UPDATE_PLAN_PACKAGES.map((name) => [name, packageRoot(name) ?? "missing-target-package"]));
+        const currentProviders = providersFromUpdatePlan(parsed, currentRoots);
+        const currentProviderPlan = prepareInstallReconcilePlanV1(currentProviders);
+        const providerObserved = new Map(currentProviderPlan.objects.map((object) => [object.object_id, object.observed_digest]));
+        for (const destination of parsed.destinations) {
+            if (destination.expected_before_digest === null)
+                continue;
+            const digest = destination.evidence_kind === "registry-version-sri"
+                ? existsSync(join(destination.path, "package.json"))
+                    ? createHash("sha256")
+                        .update(readFileSync(join(destination.path, "package.json")))
+                        .digest("hex")
+                    : null
+                : destination.evidence_kind === "bounded-target-identity"
+                    ? existsSync(destination.path)
+                        ? createHash("sha256").update(readFileSync(destination.path)).digest("hex")
+                        : null
+                    : (providerObserved.get(destination.object_id) ?? null);
+            if (digest !== destination.expected_before_digest)
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function verifyProductionInstalledPlan(plan) {
+    try {
+        const parsed = parseUpdatePlanV1(plan);
+        const installed = observeInstalledState();
+        const graph = await fetchExactPackageGraph({
+            registry: parsed.registry_url,
+            version: parsed.target_version,
+        });
+        if (!installedEvidenceMatchesPlan(parsed, installed, graph))
+            return false;
+        return parsed.target_artifacts.every((artifact) => {
+            const root = packageRoot(artifact.package);
+            return root !== null && verifyInstalledPayloadV1(root, artifact);
+        });
+    }
+    catch {
+        return false;
+    }
+}
+export function installedEvidenceMatchesPlan(plan, installed, graph) {
+    const versions = new Map(installed.packages.map((entry) => [entry.name, entry.version]));
+    return (versions.size === UPDATE_PLAN_PACKAGES.length &&
+        UPDATE_PLAN_PACKAGES.every((name) => versions.get(name) === plan.target_version) &&
+        canonicalJson(graph) === canonicalJson(plan.package_graph));
+}
+export function npmInstallArgsForUpdatePlan(plan, artifactPaths) {
+    const parsed = parseUpdatePlanV1(plan);
+    if (artifactPaths.length !== UPDATE_PLAN_PACKAGES.length) {
+        throw new Error("update-target-exact-seven-tarballs-required");
+    }
+    return Object.freeze(["i", "-g", ...artifactPaths, "--registry", parsed.registry_url]);
+}
+function runNpmInstall(plan, artifactPaths, quiet) {
+    const npmCli = resolveNpmCliPath();
+    if (npmCli === null)
+        return 1;
+    const res = spawnSync(process.execPath, [npmCli, ...npmInstallArgsForUpdatePlan(plan, artifactPaths)], {
+        stdio: quiet ? ["ignore", "pipe", "pipe"] : "inherit",
+        shell: false,
+    });
+    return res.status ?? 1;
+}
+function runReplacementReconcile(plan) {
+    const cliPath = process.argv[1];
+    if (typeof cliPath !== "string" || cliPath.length === 0 || !existsSync(cliPath)) {
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: "current Lyt CLI entrypoint is unavailable after npm replacement",
+        };
+    }
+    const result = spawnSync(process.execPath, [
+        cliPath,
+        "install",
+        "reconcile",
+        "--apply",
+        "--json",
+        "--update-operation",
+        plan.operation_id,
+        "--plan-digest",
+        plan.plan_digest,
+    ], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: false,
+    });
+    return {
+        exitCode: result.status ?? 1,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+    };
+}
+function printUpdateJson(result, currency) {
+    process.stdout.write(`${JSON.stringify({
+        schema_id: "lyt.update.v1",
+        schema_version: 1,
+        status: result.exitCode === 0 ? "completed" : "failed",
+        success: result.exitCode === 0,
+        npm_replacement_completed: result.installed,
+        reconciliation_completed: result.reconciled,
+        reconciliation_receipt: result.reconcileReceipt,
+        update_plan: result.updatePlan ?? null,
+        next_action: result.nextAction ?? null,
+        currency,
+    }, null, 2)}\n`);
+}
+async function selectChannelInteractively() {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question("Select Lyt update channel [alpha/latest] (default alpha): "))
+            .trim()
+            .toLowerCase();
+        if (answer.length === 0)
+            return "alpha";
+        return isUpdateChannel(answer) ? answer : null;
+    }
+    finally {
+        rl.close();
     }
-    fx.log("lyt update: done. Run `lyt --version` to confirm.");
-    return { installed: true, exitCode: 0 };
+}
+function productionUpdateEffects(json) {
+    return {
+        log: (message) => {
+            if (!json)
+                console.log(message);
+        },
+        error: (message) => {
+            if (!json)
+                console.error(message);
+        },
+        confirm: async (prompt) => {
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            try {
+                const answer = (await rl.question(prompt)).trim().toLowerCase();
+                return answer === "y" || answer === "yes";
+            }
+            finally {
+                rl.close();
+            }
+        },
+        preparePlan: prepareProductionUpdatePlan,
+        revalidatePlan: revalidateProductionUpdatePlan,
+        verifyInstalledPlan: verifyProductionInstalledPlan,
+        beginOperation: beginUpdateOperationV1,
+        stageArtifacts: (plan) => stageTargetArtifactsV1(plan, defaultUpdateOperationRoot()),
+        writeInstalledAnchor: (plan) => {
+            try {
+                writeInstalledStateAnchorV1(plan, defaultUpdateOperationRoot());
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        install: (plan, artifacts) => runNpmInstall(plan, artifacts, json),
+        reconcile: runReplacementReconcile,
+    };
 }
 export function buildUpdateCommand() {
     return new Command("update")
-        .description(`Update Lyt to the latest published version (runs \`npm i -g ${CURRENCY_PACKAGE}@${CURRENCY_DIST_TAG}\`). Confirms before changing your global install.`)
-        .option("--check", "Only check for a newer version; do not install (alias for `lyt outdated`)")
+        .description("Update Lyt on one explicit alpha/latest channel, then launch the replacement binary's `lyt install reconcile --apply --json` boundary. Confirms before changing the global install.")
+        .option("--check", "Only check for a newer version; do not install")
         .option("--yes", "Skip the confirmation prompt (required to update non-interactively)")
+        .option("--json", "Emit a deterministic update result")
+        .option("--channel <alpha|latest>", "Select and persist an update channel", parseChannel)
+        .option("--switch-channel", "Allow changing a previously selected channel (requires --channel)")
+        .option("--allow-downgrade", "Allow the explicit selected channel to replace an ahead install")
+        .option("--resume <operation-id>", "Resume one durable update operation after npm replacement")
+        .option("--configure", "Persist --channel without checking or installing")
         .action(async (opts) => {
-        const result = await checkCurrency({ force: true });
-        if (opts.check === true) {
-            console.log(formatCurrencyLine(result));
-            process.exitCode = result.stale ? 1 : 0;
+        const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true && opts.json !== true;
+        const effects = productionUpdateEffects(opts.json === true);
+        if (opts.configure === true) {
+            if (opts.channel === undefined || opts.resume !== undefined || opts.check === true) {
+                const nextAction = "lyt update --channel <alpha|latest> --configure --json";
+                if (opts.json) {
+                    process.stdout.write(`${JSON.stringify({
+                        schema_id: "lyt.update-channel-configure-refusal",
+                        schema_version: { major: 1, minor: 0 },
+                        status: "refused",
+                        error_code: "update-channel-configure-requires-channel-only",
+                        next_action: nextAction,
+                    })}\n`);
+                }
+                else
+                    console.error(`lyt update: run \`${nextAction}\`.`);
+                process.exitCode = 2;
+                return;
+            }
+            const configured = configureUpdateChannel(opts.channel);
+            if (opts.json)
+                process.stdout.write(`${JSON.stringify(configured)}\n`);
+            else
+                console.log(`Lyt update channel saved: ${configured.channel}.`);
             return;
         }
-        const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
-        const { exitCode } = await runUpdateFlow(result, { yes: opts.yes, interactive }, {
-            log: (m) => console.log(m),
-            error: (m) => console.error(m),
-            confirm: async (prompt) => {
-                const rl = createInterface({ input: process.stdin, output: process.stdout });
-                try {
-                    const answer = (await rl.question(prompt)).trim().toLowerCase();
-                    return answer === "y" || answer === "yes";
-                }
-                finally {
-                    rl.close();
-                }
-            },
-            install: () => {
-                const res = spawnSync("npm", ["i", "-g", `${CURRENCY_PACKAGE}@${CURRENCY_DIST_TAG}`], {
-                    stdio: "inherit",
-                    shell: process.platform === "win32",
-                });
-                return res.status ?? 1;
-            },
+        if (opts.resume !== undefined) {
+            let result;
+            try {
+                result = await resumeUpdateFlow(opts.resume, effects);
+            }
+            catch (error) {
+                effects.error(`lyt update: could not resume the sealed update operation (${String(error)}).`);
+                result = {
+                    installed: false,
+                    reconciled: false,
+                    reconcileReceipt: null,
+                    exitCode: 1,
+                    nextAction: "lyt doctor --json",
+                };
+            }
+            if (opts.json)
+                printUpdateJson(result, null);
+            if (result.exitCode !== 0)
+                process.exitCode = result.exitCode;
+            return;
+        }
+        if (opts.switchChannel === true && opts.channel === undefined) {
+            const result = {
+                installed: false,
+                reconciled: false,
+                reconcileReceipt: null,
+                exitCode: 2,
+                nextAction: "lyt update --channel alpha --switch-channel",
+            };
+            if (opts.json)
+                printUpdateJson(result, await checkCurrency({ installedVersion: readMetaVersion() }));
+            else
+                console.error("lyt update: --switch-channel requires --channel alpha|latest.");
+            process.exitCode = 2;
+            return;
+        }
+        if (opts.allowDowngrade === true && opts.channel === undefined) {
+            const result = {
+                installed: false,
+                reconciled: false,
+                reconcileReceipt: null,
+                exitCode: 2,
+                nextAction: "lyt update --channel alpha --allow-downgrade",
+            };
+            if (opts.json)
+                printUpdateJson(result, await checkCurrency({ installedVersion: readMetaVersion() }));
+            else
+                console.error("lyt update: --allow-downgrade requires --channel alpha|latest.");
+            process.exitCode = 2;
+            return;
+        }
+        const persisted = readUpdateChannel();
+        const initial = opts.check === true && opts.channel !== undefined
+            ? { channel: opts.channel, source: "explicit" }
+            : resolveConfiguredChannel(opts.channel, persisted, {
+                switchChannel: opts.switchChannel,
+                interactive,
+            });
+        const resolved = initial.channel === null && initial.refusal === "channel-unconfigured" && interactive
+            ? resolveConfiguredChannel(opts.channel, persisted, {
+                switchChannel: opts.switchChannel,
+                interactive,
+                selectedInteractive: await selectChannelInteractively(),
+            })
+            : initial;
+        if (resolved.channel === null) {
+            const currency = await checkCurrency({ installedVersion: readMetaVersion() });
+            const result = {
+                installed: false,
+                reconciled: false,
+                reconcileReceipt: null,
+                exitCode: 2,
+                nextAction: resolved.nextAction,
+            };
+            if (opts.json)
+                printUpdateJson(result, currency);
+            else
+                console.error(resolved.refusal === "channel-switch-requires-explicit"
+                    ? `lyt update: run \`${resolved.nextAction}\` to switch the saved channel.`
+                    : formatCurrencyLine(currency));
+            process.exitCode = 2;
+            return;
+        }
+        if (opts.check !== true &&
+            (resolved.source === "explicit" || resolved.source === "interactive")) {
+            writeUpdateChannel(resolved.channel);
+        }
+        const currency = await checkCurrency({
+            force: true,
+            channel: resolved.channel,
+            installedVersion: readMetaVersion(),
         });
+        if (opts.check === true) {
+            if (opts.json)
+                process.stdout.write(`${JSON.stringify(currency, null, 2)}\n`);
+            else
+                console.log(formatCurrencyLine(currency));
+            process.exitCode = currency.stale ? 1 : currency.channelUnconfigured ? 2 : 0;
+            return;
+        }
+        const { exitCode, ...flowResult } = await runUpdateFlow(currency, { yes: opts.yes, interactive, allowDowngrade: opts.allowDowngrade }, effects);
+        const result = { ...flowResult, exitCode };
+        if (opts.json)
+            printUpdateJson(result, currency);
         if (exitCode !== 0)
             process.exitCode = exitCode;
     });