maka-agent 0.2.0-dev.6.20260830 → 0.2.0-dev.9.20260831

package/dist/runtime-host-local-handoff.js

@@ -19,14 +19,17 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { realpath, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { join, posix, resolve, win32 } from 'node:path';
+import { dirname, join, posix, resolve, win32 } from 'node:path';
 import { claimLocalHostProcessDeployment, handoffLocalHostProcessDeployment, readLocalHostDeploymentRecord, } from '@maka/runtime-host/operator';
-import { connectOrSpawnRuntimeHost, runtimeHostStartupError } from '@maka/runtime-host/client';
+import { compareProductReleaseVersions } from '@maka/runtime-host/operator/update-package-evidence';
+import { connectExistingRuntimeHost } from '@maka/runtime-host/client';
 import { INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID, RUNTIME_HOST_PROTOCOL_VERSION, } from '@maka/runtime-host/protocol';
 import { resolveRuntimeHostNpmGlobalInstallation, } from './runtime-host-cli-installation.js';
-import { prepareRuntimeHostPackageDeployment, } from './runtime-host-package-deployment.js';
+import { openRuntimeHostPackageDeployment, prepareRuntimeHostPackageDeployment, resolveRuntimeHostPackageCliPath, } from './runtime-host-package-deployment.js';
 import { RuntimeHostUpdatePackageError, withRuntimeHostRegistryUpdatePackage, } from './runtime-host-update-package.js';
 import { resolveRuntimeHostRegistryUpdateCandidate } from './runtime-host-update-discovery.js';
+import { launchRuntimeHostTargetActivator, } from './runtime-host-local-target-activation.js';
+import { launchRuntimeHostLocalSourceRetirement } from './runtime-host-local-source-retirement.js';
 const ROOT_ID = /^[a-f0-9]{64}$/u;
 const CANDIDATE_RELATIVE_PATH = [
     'node_modules',
@@ -45,8 +48,9 @@ export class RuntimeHostLocalHandoffError extends Error {
 }
 /**
  * Explicitly restarts one local ephemeral Host from the exact artifact matching
- * the installed npm-global CLI. The released-Host takeover is a bounded adapter:
- * it can replace only the observed exact Host when that Host reports true idle.
+ * the installed npm-global CLI. A durable selected source may retire its exact
+ * Host through its own compatible client; released Hosts without that helper
+ * retain only the bounded true-idle takeover adapter.
  */
 export async function restartRuntimeHostNpmGlobalDeployment(input, authorityOptions = {}, overrides = {}) {
     if (input.registration.lifecycleMode !== 'ephemeral') {
@@ -63,15 +67,21 @@ export async function restartRuntimeHostNpmGlobalDeployment(input, authorityOpti
         claim: claimLocalHostProcessDeployment,
         handoff: handoffLocalHostProcessDeployment,
         resolveCandidate: resolveRuntimeHostRegistryUpdateCandidate,
-        connectOrSpawn: connectOrSpawnRuntimeHost,
+        connectExisting: connectExistingRuntimeHost,
+        activateTarget: launchRuntimeHostTargetActivator,
+        retireSource: launchRuntimeHostLocalSourceRetirement,
         ...overrides,
     };
     const installation = await deps.resolveInstallation(input.installationOptions);
+    const current = await deps.readRecord(input.registration.rootId, authorityOptions);
+    const sourceOwner = current?.state.kind === 'handoff' ? current.state.from : current?.state.owner;
+    if (sourceOwner && !sameOwner(sourceOwner, installation.owner)) {
+        throw new RuntimeHostLocalHandoffError('source_owner_mismatch', 'External npm replacement can reconcile only the same durable npm-global installation owner');
+    }
     const target = await deps.resolveCandidate({
         kind: 'exact',
         version: installation.observedRelease.version,
     });
-    const current = await deps.readRecord(input.registration.rootId, authorityOptions);
     if (current?.state.kind === 'owned' &&
         current.state.owner.kind === installation.owner.kind &&
         current.state.owner.installationId === installation.owner.installationId &&
@@ -80,70 +90,158 @@ export async function restartRuntimeHostNpmGlobalDeployment(input, authorityOpti
         current.state.selected.integrity === target.integrity) {
         throw new RuntimeHostLocalHandoffError('selected_target_observation_conflict', 'The active Runtime Host conflicts with the deployment already committed for this installation');
     }
+    if (current &&
+        compareProductReleaseVersions(target.version, current.state.selected.version) < 0) {
+        throw new RuntimeHostLocalHandoffError('unsupported_downgrade', `Downgrading the local Runtime Host from ${current.state.selected.version} to ${target.version} is not supported`);
+    }
     const transactionId = restartTransactionId(input.registration.rootId, installation.owner, target);
-    let connectedTarget;
-    const prepare = async (rootId, staged) => {
+    const activeWorkPolicy = input.activeWorkPolicy ?? 'refuse_active_work';
+    const staged = await stageRuntimeHostNpmGlobalDeploymentTarget({
+        rootId: input.registration.rootId,
+        owner: installation.owner,
+        target,
+        transactionId,
+    }, input.deploymentPathOptions, deps);
+    const selected = current?.state.selected;
+    const sourceIdentity = selected && !sameDeployment(selected, target) ? selected : undefined;
+    const source = sourceIdentity
+        ? await openRuntimeHostNpmGlobalStagedDeployment({
+            rootId: input.registration.rootId,
+            owner: installation.owner,
+            target: sourceIdentity,
+            transactionId: `${transactionId}:source`,
+        }, input.deploymentPathOptions)
+        : undefined;
+    const sourceSupportsRetirement = source ? await hasSourceRetirementHelper(source) : false;
+    let targetActivator;
+    const activateExactTarget = async (rootId, stagedTarget, inheritableAuthorityLeaseFd, takeoverHostEpoch) => {
+        const activated = await deps.activateTarget({
+            rootPath: input.rootPath,
+            rootId,
+            staged: stagedTarget,
+            ownerInstallationId: installation.owner.installationId,
+            target,
+            inheritableAuthorityLeaseFd,
+            ...(takeoverHostEpoch ? { takeoverHostEpoch } : {}),
+        });
+        if (activated.kind !== 'ready')
+            return activated.kind;
+        targetActivator = activated;
+        return 'target_present';
+    };
+    const prepare = async (rootId, selectedDeployment, stagedTarget, inheritableAuthorityLeaseFd) => {
         if (rootId !== input.registration.rootId) {
             throw new RuntimeHostLocalHandoffError('root_changed', 'The local Runtime Host State Root changed before restart');
         }
-        const result = await deps.connectOrSpawn({
+        const observed = await deps.connectExisting({
             rootPath: input.rootPath,
             protocol: { min: RUNTIME_HOST_PROTOCOL_VERSION, max: RUNTIME_HOST_PROTOCOL_VERSION },
             compositionId: INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID,
-            generation: staged.launchGeneration,
-            takeoverHostEpoch: input.registration.hostEpoch,
             clientInstanceId: randomUUID(),
-            candidateEntrypoint: staged.candidateEntrypoint,
         });
-        if (result.kind === 'connected') {
-            if (result.registration.rootId !== rootId ||
-                result.registration.generation !== staged.launchGeneration ||
-                (result.spawnedProcess !== undefined &&
-                    result.spawnedProcess.pid !== result.registration.pid)) {
-                await result.connection.close().catch(() => undefined);
-                throw new Error('The restarted Runtime Host does not match the exact staged process');
+        const registration = observed.registration;
+        if (registration?.rootId !== undefined && registration.rootId !== rootId) {
+            if (observed.kind === 'connected')
+                await observed.connection.close().catch(() => undefined);
+            throw new RuntimeHostLocalHandoffError('root_changed', 'The local Runtime Host State Root changed during restart');
+        }
+        if (observed.kind === 'connected')
+            await observed.connection.close();
+        if (!registration) {
+            const activated = await activateExactTarget(rootId, stagedTarget, inheritableAuthorityLeaseFd);
+            if (activated !== 'target_present') {
+                throw new Error('The exact target could not start after the source Host disappeared');
             }
-            connectedTarget = result;
             return { kind: 'target_present' };
         }
-        if ((result.kind === 'incompatible' || result.kind === 'upgrade_required') &&
-            result.registration.hostEpoch === input.registration.hostEpoch) {
-            return { kind: 'active_work' };
+        if (registration.lifecycleMode !== 'ephemeral') {
+            throw new Error('The observed Runtime Host requires its operator to perform replacement');
+        }
+        if (registration.generation === stagedTarget.launchGeneration) {
+            const activated = await activateExactTarget(rootId, stagedTarget, inheritableAuthorityLeaseFd);
+            if (activated !== 'target_present') {
+                throw new Error('The exact staged Runtime Host could not be reattached for recovery');
+            }
+            return { kind: 'target_present' };
+        }
+        if (registration.hostEpoch !== input.registration.hostEpoch) {
+            throw new Error('The observed Runtime Host changed after restart confirmation');
         }
-        if (result.kind === 'failed') {
-            throw runtimeHostStartupError(result.reason, result.diagnostic);
+        if (source &&
+            sourceSupportsRetirement &&
+            selectedDeployment &&
+            sourceIdentity &&
+            sameDeployment(selectedDeployment, sourceIdentity)) {
+            const retired = await deps.retireSource({
+                sourceCliPath: source.cliPath,
+                rootPath: input.rootPath,
+                expectedRootId: rootId,
+                expectedHostEpoch: registration.hostEpoch,
+                activeWorkPolicy,
+                inheritableAuthorityLeaseFd,
+            });
+            if (retired === 'active_work')
+                return { kind: 'active_work' };
+            if (retired === 'operator_required') {
+                throw new Error('The observed Runtime Host requires its operator to perform replacement');
+            }
+            const activated = await activateExactTarget(rootId, stagedTarget, inheritableAuthorityLeaseFd, registration.hostEpoch);
+            if (activated !== 'target_present') {
+                throw new Error('The exact target did not activate after source retirement began');
+            }
+            return { kind: 'target_present' };
+        }
+        const activated = await activateExactTarget(rootId, stagedTarget, inheritableAuthorityLeaseFd, registration.hostEpoch);
+        if (activated === 'active_work')
+            return { kind: 'active_work' };
+        if (activated === 'operator_required') {
+            throw new Error('The observed Runtime Host requires its operator to perform replacement');
         }
-        throw new Error('The observed Runtime Host changed before exact local restart completed');
+        return { kind: 'target_present' };
     };
     const unreachable = async () => {
-        throw new Error('Legacy local restart must converge during exact takeover');
+        throw new Error('Local restart must converge through its exact target activator');
     };
+    let result;
     try {
-        return await reconcileRuntimeHostNpmGlobalDeployment({
+        result = await reconcilePreparedRuntimeHostNpmGlobalDeployment({
             rootId: input.registration.rootId,
             transactionId,
             target,
-            activeWorkPolicy: 'refuse_active_work',
-            ...(input.installationOptions ? { installationOptions: input.installationOptions } : {}),
+            activeWorkPolicy,
+            installation,
+            staged,
             ...(input.deploymentPathOptions
                 ? { deploymentPathOptions: input.deploymentPathOptions }
                 : {}),
         }, {
-            prepareUnownedHostCutover: (rootId, _target, staged) => prepare(rootId, staged),
-            prepareHostCutover: (rootId, _selected, _target, staged) => prepare(rootId, staged),
+            prepareUnownedHostCutover: (rootId, _target, stagedTarget, _policy, leaseFd) => prepare(rootId, undefined, stagedTarget, leaseFd),
+            prepareHostCutover: (rootId, selectedDeployment, _target, stagedTarget, _policy, leaseFd) => prepare(rootId, selectedDeployment, stagedTarget, leaseFd),
             observeWriterRelease: unreachable,
             activateTarget: unreachable,
-            async verifyTargetReady(rootId, _target, staged) {
-                if (connectedTarget?.registration.rootId !== rootId ||
-                    connectedTarget.registration.generation !== staged.launchGeneration) {
+            async verifyTargetReady() {
+                if (targetActivator?.kind !== 'ready') {
                     throw new Error('Exact restarted Runtime Host Ready evidence is unavailable');
                 }
-                await connectedTarget.connection.close();
+            },
+            async finalizeTarget() {
+                const observedInstallation = await deps.resolveInstallation(input.installationOptions);
+                if (observedInstallation.owner.installationId !== installation.owner.installationId ||
+                    observedInstallation.observedRelease.version !== target.version) {
+                    throw new RuntimeHostLocalHandoffError('installed_release_mismatch', 'The installed Maka release changed again before local Host ownership committed');
+                }
             },
         }, authorityOptions, deps);
+        return result;
     }
     finally {
-        await connectedTarget?.connection.close().catch(() => undefined);
+        if (targetActivator) {
+            const settlement = targetActivator.settle();
+            if (result?.kind === 'completed')
+                await settlement;
+            else
+                await settlement.catch(() => undefined);
+        }
     }
 }
 /**
@@ -233,6 +331,20 @@ export async function prepareRuntimeHostNpmGlobalStagedDeployment(input, pathOpt
         launchGeneration: launchGeneration(input.transactionId, input.target),
     };
 }
+async function openRuntimeHostNpmGlobalStagedDeployment(input, pathOptions = {}) {
+    const deploymentRoot = resolveRuntimeHostLocalCliDeploymentRoot(input.rootId, input.owner, pathOptions);
+    const staged = await openRuntimeHostPackageDeployment({
+        deploymentRoot,
+        cliPath: resolveRuntimeHostPackageCliPath(deploymentRoot, input.target.version, input.target.integrity),
+        version: input.target.version,
+    });
+    const candidateEntrypoint = await requireCandidateEntrypoint(staged.packageRoot);
+    return {
+        ...staged,
+        candidateEntrypoint,
+        launchGeneration: launchGeneration(input.transactionId, input.target),
+    };
+}
 export function resolveRuntimeHostLocalCliDeploymentRoot(rootId, owner, options = {}) {
     if (!ROOT_ID.test(rootId) || owner.kind !== 'cli' || owner.installationId.length === 0) {
         throw new TypeError('Invalid local Runtime Host CLI deployment identity');
@@ -267,6 +379,22 @@ async function requireCandidateEntrypoint(packageRoot) {
     }
     return candidate;
 }
+async function hasSourceRetirementHelper(source) {
+    try {
+        return (await stat(join(dirname(source.cliPath), 'runtime-host-local-source-retirement.js'))).isFile();
+    }
+    catch (error) {
+        if (isNodeError(error, 'ENOENT'))
+            return false;
+        throw error;
+    }
+}
+function sameDeployment(left, right) {
+    return (left.kind === right.kind && left.version === right.version && left.integrity === right.integrity);
+}
+function sameOwner(left, right) {
+    return left.kind === right.kind && left.installationId === right.installationId;
+}
 function launchGeneration(transactionId, target) {
     return `npm-global-handoff:${createHash('sha256')
         .update(transactionId)
@@ -292,3 +420,6 @@ function restartTransactionId(rootId, owner, target) {
 function invalidStagedPackage(message, cause) {
     return new RuntimeHostUpdatePackageError('invalid_package', message, { cause });
 }
+function isNodeError(error, code) {
+    return error instanceof Error && 'code' in error && error.code === code;
+}

package/dist/runtime-host-local-source-retirement.js

@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { spawn } from 'node:child_process';
+import { connectExistingRuntimeHost, prepareConnectedRuntimeHostRetirement, } from '@maka/runtime-host/client';
+import { INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID, RUNTIME_HOST_PROTOCOL_VERSION, } from '@maka/runtime-host/protocol';
+const SOURCE_RETIREMENT_TIMEOUT_MS = 60_000;
+/**
+ * Runs inside the exact selected source package so its client protocol remains
+ * compatible with the Host that package launched. The parent owns deployment
+ * authority; this helper only exercises the authenticated retirement contract.
+ */
+export async function runRuntimeHostLocalSourceRetirement(input, overrides = {}) {
+    const connectExisting = overrides.connectExisting ?? connectExistingRuntimeHost;
+    const prepareRetirement = overrides.prepareRetirement ?? prepareConnectedRuntimeHostRetirement;
+    const connected = await connectExisting({
+        rootPath: input.rootPath,
+        protocol: { min: RUNTIME_HOST_PROTOCOL_VERSION, max: RUNTIME_HOST_PROTOCOL_VERSION },
+        compositionId: INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID,
+    });
+    if (connected.kind !== 'connected') {
+        if (connected.registration && connected.registration.lifecycleMode !== 'ephemeral')
+            return 4;
+        throw new Error('The selected source package cannot control the observed Runtime Host');
+    }
+    try {
+        if (connected.registration.rootId !== input.expectedRootId ||
+            connected.registration.hostEpoch !== input.expectedHostEpoch) {
+            throw new Error('The Runtime Host changed before source-package retirement');
+        }
+        if (connected.registration.lifecycleMode !== 'ephemeral')
+            return 4;
+        const prepared = await prepareRetirement(connected.connection, input.activeWorkPolicy);
+        if (prepared.kind === 'active_tasks')
+            return 2;
+        if (prepared.pid !== connected.registration.pid) {
+            throw new Error('The Runtime Host process changed while source retirement was prepared');
+        }
+        return 0;
+    }
+    finally {
+        await connected.connection.close().catch(() => undefined);
+    }
+}
+export function launchRuntimeHostLocalSourceRetirement(input) {
+    const args = [
+        input.sourceCliPath,
+        'runtime-host',
+        'local-source-retire',
+        '--root',
+        input.rootPath,
+        '--expected-root-id',
+        input.expectedRootId,
+        '--expected-host-epoch',
+        input.expectedHostEpoch,
+        ...(input.activeWorkPolicy === 'interrupt_active_work'
+            ? ['--allow-interrupt-active-tasks']
+            : []),
+    ];
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, args, {
+            // fd 4 inherits the existing owner-authority lease. The source helper
+            // holds it only while the authenticated retirement request is in flight.
+            stdio: ['ignore', 'ignore', 'inherit', 'ignore', input.inheritableAuthorityLeaseFd],
+            timeout: SOURCE_RETIREMENT_TIMEOUT_MS,
+            killSignal: 'SIGKILL',
+            windowsHide: false,
+        });
+        child.once('error', reject);
+        child.once('close', (code, signal) => {
+            if (signal) {
+                reject(new Error(`Maka source retirement helper exited on ${signal}`));
+            }
+            else if (code === 0) {
+                resolve('prepared');
+            }
+            else if (code === 2) {
+                resolve('active_work');
+            }
+            else if (code === 4) {
+                resolve('operator_required');
+            }
+            else {
+                reject(new Error('The selected Maka source package could not retire its Runtime Host'));
+            }
+        });
+    });
+}

package/dist/runtime-host-local-target-activation.js

@@ -0,0 +1,141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { spawn } from 'node:child_process';
+const TARGET_ACTIVATOR_SETTLEMENT_TIMEOUT_MS = 15_000;
+export class RuntimeHostTargetActivationError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = 'RuntimeHostTargetActivationError';
+    }
+}
+/**
+ * Launches the exact staged target through its own release and keeps the
+ * existing owner-authority lease in the activator until durable commit.
+ */
+export function launchRuntimeHostTargetActivator(input, options = {}) {
+    const args = [
+        input.staged.cliPath,
+        'runtime-host',
+        'local-update-activate',
+        '--root',
+        input.rootPath,
+        '--expected-root-id',
+        input.rootId,
+        '--generation',
+        input.staged.launchGeneration,
+        '--candidate-entrypoint',
+        input.staged.candidateEntrypoint,
+        '--await-coordinator-commit',
+        'true',
+        '--expected-owner-installation-id',
+        input.ownerInstallationId,
+        '--target-version',
+        input.target.version,
+        '--target-integrity',
+        input.target.integrity,
+        ...(input.takeoverHostEpoch ? ['--takeover-host-epoch', input.takeoverHostEpoch] : []),
+    ];
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, args, {
+            // fd 3 is the coordinator channel; fd 4 is the inherited authority
+            // lease. The activator, not the long-lived target, owns that lease.
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc', input.inheritableAuthorityLeaseFd],
+            windowsHide: false,
+        });
+        let ready = false;
+        let settled = false;
+        const closed = new Promise((resolveClosed) => {
+            child.once('close', (code, signal) => resolveClosed({ code, signal }));
+        });
+        const closeError = async () => {
+            const { code, signal } = await closed;
+            if (signal)
+                throw new Error(`Maka target activator exited on ${signal}`);
+            if (code === 3)
+                throw new Error('The activated Runtime Host still owns active work');
+            if (code === 4)
+                throw new Error('The observed Runtime Host requires its operator');
+            throw new Error('The exact Maka target could not be activated');
+        };
+        const settle = async () => {
+            if (settled)
+                return;
+            settled = true;
+            let settlementTimedOut = false;
+            // This parent owns the activator process and therefore the hard bound.
+            // Killing and then awaiting close releases its inherited lease even when
+            // an individual authority read in the child never settles.
+            const settlementTimer = setTimeout(() => {
+                settlementTimedOut = true;
+                child.kill('SIGKILL');
+            }, options.settlementTimeoutMs ?? TARGET_ACTIVATOR_SETTLEMENT_TIMEOUT_MS);
+            settlementTimer.unref();
+            if (child.connected) {
+                try {
+                    child.send({ kind: 'settle' });
+                }
+                catch {
+                    // The close result below remains the only settlement evidence.
+                }
+            }
+            try {
+                const exited = await closed;
+                if (settlementTimedOut) {
+                    throw new RuntimeHostTargetActivationError('recovery_required', 'The local Runtime Host update requires recovery because its target activator exceeded the durable settlement deadline');
+                }
+                if (!exited.signal && exited.code === 0)
+                    return;
+                throw new RuntimeHostTargetActivationError('recovery_required', exited.signal
+                    ? `The local Runtime Host update requires recovery because its target activator exited on ${exited.signal}`
+                    : 'The local Runtime Host update requires recovery because its target activator could not confirm durable ownership');
+            }
+            finally {
+                clearTimeout(settlementTimer);
+            }
+        };
+        child.once('error', reject);
+        child.on('message', (message) => {
+            if (ready || !isTargetActivatorReadyMessage(message))
+                return;
+            ready = true;
+            resolve({ kind: 'ready', settle });
+        });
+        void closed.then(({ code, signal }) => {
+            if (ready)
+                return;
+            if (signal) {
+                reject(new Error(`Maka target activator exited on ${signal}`));
+            }
+            else if (code === 3) {
+                resolve({ kind: 'active_work', settle: async () => undefined });
+            }
+            else if (code === 4) {
+                resolve({ kind: 'operator_required', settle: async () => undefined });
+            }
+            else {
+                void closeError().catch(reject);
+            }
+        });
+    });
+}
+function isTargetActivatorReadyMessage(value) {
+    return (typeof value === 'object' && value !== null && value.kind === 'ready');
+}

package/dist/runtime-host-peer-management-command.js

@@ -23,7 +23,7 @@ import { isDeepStrictEqual } from 'node:util';
 import { networkInterfaces } from 'node:os';
 import { encodeRuntimeHostPeerManagementFrame, resolveRuntimeHostNpmDeploymentLayout, } from '@maka/runtime-host/operator';
 import { ensureRuntimeHostPeerIdentity } from '@maka/runtime-host/client';
-import { hasActivePeerMeshMembership } from '@maka/runtime-host/peer-mesh';
+import { hasPeerMeshIdentityObligations } from '@maka/runtime-host/peer-mesh';
 import { allocateRuntimeHostPeerPort, RuntimeHostServiceManagerError, withRuntimeHostManagedServiceDeploymentLock, withRuntimeHostManagedServiceLifecycleLock, } from './runtime-host-service-manager.js';
 import { resolveRuntimeHostLifecycleProvider } from './runtime-host-service-management-command.js';
 import { canDiscardRuntimeHostLifecycleDesiredArtifacts, replaceRuntimeHostLifecycle, resolveRecoverableRuntimeHostManagedDeployment, activateRuntimeHostLifecycle, verifyRuntimeHostLifecycleReady, } from './runtime-host-lifecycle-transaction.js';
@@ -67,6 +67,7 @@ async function runCanonicalRuntimeHostPeerManagementLocked(options, deps) {
     let desired = config;
     let stagedKeyPath;
     let previousPeerId;
+    let validateRetiredState;
     let restarted;
     if (options.action === 'enable') {
         const peer = await prepareCanonicalPeer(options, config, config.listeners.directPeer);
@@ -93,9 +94,13 @@ async function runCanonicalRuntimeHostPeerManagementLocked(options, deps) {
         if (!current?.enabled) {
             throw new RuntimeHostServiceManagerError('not_installed', 'Direct peer is not enabled for the managed Runtime Host deployment');
         }
-        if (await hasActivePeerMeshMembership(join(config.deploymentRoot, 'peer-mesh', current.peerId), current.peerId)) {
-            throw new RuntimeHostServiceManagerError('invalid_config', 'Close or leave every active Peer Mesh before rotating the Direct peer identity');
-        }
+        validateRetiredState = async () => {
+            if (!(await hasPeerMeshIdentityObligations(join(config.deploymentRoot, 'peer-mesh', current.peerId), current.peerId))) {
+                return;
+            }
+            throw new RuntimeHostServiceManagerError('invalid_config', 'Close or finish leaving every Peer Mesh before rotating the Direct peer identity');
+        };
+        await validateRetiredState();
         previousPeerId = current.peerId;
         stagedKeyPath = join(dirname(current.keyPath), `runtime-host-peer.${randomUUID()}.key`);
         const layout = resolveRuntimeHostNpmDeploymentLayout(config.deploymentRoot, config.launch.package.integrity);
@@ -119,6 +124,7 @@ async function runCanonicalRuntimeHostPeerManagementLocked(options, deps) {
             desired,
             allowInterruptActiveTasks: options.allowInterruptActiveTasks ?? false,
             deps: lifecycleDeps,
+            ...(validateRetiredState ? { validateRetiredState } : {}),
         }).catch(async (error) => {
             if (stagedKeyPath && canDiscardRuntimeHostLifecycleDesiredArtifacts(error)) {
                 await rm(stagedKeyPath, { force: true }).catch(() => undefined);

package/node_modules/@maka/core/dist/agent-run.js

@@ -161,8 +161,6 @@ export const AGENT_RUN_EVENT_TYPES = [
     'run_created',
     'run_started',
     'turn_started',
-    'sandbox_context_resolved',
-    'sandbox_context_failed',
     'plan_context_resolved',
     'plan_submitted',
     'plan_execution_started',

package/node_modules/@maka/core/dist/artifacts.js

@@ -60,6 +60,7 @@ export function resolveArtifactImagePreview(input) {
 }
 export const ARTIFACT_SOURCES = [
     'tool_result',
+    'tool_result_projection',
     'tool_result_archive',
     'synthesis_cache_block',
     'history_compact_block',
@@ -87,21 +88,28 @@ export function isArtifactTurnKey(value) {
         value.length <= ARTIFACT_TURN_KEY_MAX_CHARS &&
         !ARTIFACT_TURN_KEY_CONTROL_CHARACTERS.test(value));
 }
-const ARTIFACT_USER_DELETE_ALLOWED_BY_SOURCE = {
-    tool_result: true,
-    tool_result_archive: false,
-    synthesis_cache_block: true,
-    history_compact_block: true,
-    history_compact_source: true,
-    provider_request_capture: true,
-    subagent_writeback: false,
-    deep_research: false,
-    user_upload: true,
-    export: true,
-    snapshot: true,
-    session_effect: false,
-    fixture: true,
+const ARTIFACT_SOURCE_POLICIES = {
+    tool_result: { userDeletable: true, userVisible: false, sharedReadable: true },
+    tool_result_projection: { userDeletable: false, userVisible: false, sharedReadable: true },
+    tool_result_archive: { userDeletable: false, userVisible: false, sharedReadable: false },
+    synthesis_cache_block: { userDeletable: true, userVisible: false, sharedReadable: false },
+    history_compact_block: { userDeletable: true, userVisible: false, sharedReadable: false },
+    history_compact_source: { userDeletable: true, userVisible: false, sharedReadable: false },
+    provider_request_capture: { userDeletable: true, userVisible: false, sharedReadable: false },
+    subagent_writeback: { userDeletable: false, userVisible: true, sharedReadable: false },
+    deep_research: { userDeletable: false, userVisible: true, sharedReadable: false },
+    user_upload: { userDeletable: true, userVisible: false, sharedReadable: true },
+    export: { userDeletable: true, userVisible: true, sharedReadable: false },
+    snapshot: { userDeletable: true, userVisible: true, sharedReadable: false },
+    session_effect: { userDeletable: false, userVisible: false, sharedReadable: false },
+    fixture: { userDeletable: true, userVisible: true, sharedReadable: false },
 };
 export function canUserDeleteArtifact(record) {
-    return record.source === undefined || ARTIFACT_USER_DELETE_ALLOWED_BY_SOURCE[record.source];
+    return record.source === undefined || ARTIFACT_SOURCE_POLICIES[record.source].userDeletable;
+}
+export function isArtifactUserVisible(record) {
+    return record.source === undefined || ARTIFACT_SOURCE_POLICIES[record.source].userVisible;
+}
+export function isArtifactSharedSessionReadable(record) {
+    return record.source !== undefined && ARTIFACT_SOURCE_POLICIES[record.source].sharedReadable;
 }