@loucompanion/forge-bridge 0.1.3-dev.ba7d36726eda → 0.1.3-dev.bca7d0ccee53

package/dist/runtime/host-runtime-lease.js

@@ -11,6 +11,7 @@ import { HostListenerInspector } from "./host-listener-inspector.js";
 import { PlaywrightHostRuntimeAdapter } from "./playwright-host-runtime-adapter.js";
 import { HostParallelPromotionStore, configuredLaunchPortNames, hostRuntimeContractFingerprint, hostRuntimeParallelEligible, } from "./host-runtime-promotion.js";
 import { ExactHostProcessRecovery, } from "../shared/process/host-process-recovery.js";
+import { resetGeneratedOutputs } from "./generated-output-reset.js";
 export class HostRuntimeLeaseManager {
     stateRoot;
     processSupervisors;
@@ -27,6 +28,7 @@ export class HostRuntimeLeaseManager {
     parallelProjectOwners = new Map();
     parallelProjectWaiters = [];
     degraded = new Map();
+    knownPromotions = new Map();
     portBroker;
     nodeAdapter;
     constructor(stateRoot, portBroker = new HostPortBroker(), nodeAdapter, processSupervisors = new AttemptProcessSupervisorRegistry(), processRunner = new StreamingProviderProcessRunner(), listenerInspector = new HostListenerInspector(), promotionStore = new HostParallelPromotionStore(stateRoot), playwrightAdapter = new PlaywrightHostRuntimeAdapter(), processRecovery = new ExactHostProcessRecovery()) {
@@ -41,6 +43,7 @@ export class HostRuntimeLeaseManager {
         this.nodeAdapter = nodeAdapter ?? new NodeHostRuntimeAdapter(portBroker);
     }
     async reap(options) {
+        await this.refreshKnownPromotions();
         const report = {
             examined: 0,
             reaped: 0,
@@ -50,8 +53,25 @@ export class HostRuntimeLeaseManager {
         };
         for (const ledger of await this.readLedgers()) {
             const lease = ledger.runtimeLease;
-            if (lease.runnerId !== options.runnerId || this.active.has(lease.dispatchAttemptId))
+            if (lease.runnerId !== options.runnerId)
                 continue;
+            const active = this.active.get(lease.dispatchAttemptId);
+            if (active) {
+                if (active.lease.state !== "degraded")
+                    continue;
+                report.examined += 1;
+                try {
+                    const released = await this.release(lease.dispatchAttemptId, lease.fencingToken);
+                    if (released?.state === "released")
+                        report.reaped += 1;
+                    else
+                        report.degraded += 1;
+                }
+                catch {
+                    report.degraded += 1;
+                }
+                continue;
+            }
             const staleInstance = lease.runnerInstanceId !== options.runnerInstanceId;
             const expired = Date.parse(lease.expiresAt) <= (options.nowMs ?? Date.now());
             if (!staleInstance && !expired && lease.state !== "released" && lease.state !== "degraded")
@@ -91,6 +111,13 @@ export class HostRuntimeLeaseManager {
     }
     snapshot() {
         const projects = new Map();
+        for (const promotion of this.knownPromotions.values()) {
+            const project = capacityProject(projects, promotion.repoId);
+            project.safetyClass = conservativeSafetyClass(project.safetyClass, "host_parallel_safe");
+            project.runtimeContractFingerprint = promotion.runtimeContractFingerprint;
+            project.runtimeContractSource = promotion.runtimeContractSource ?? null;
+            project.promotedAt = promotion.observedAt;
+        }
         for (const [dispatchAttemptId, admission] of this.admissions) {
             const active = this.active.get(dispatchAttemptId);
             const project = capacityProject(projects, admission.repoId);
@@ -101,17 +128,21 @@ export class HostRuntimeLeaseManager {
                 }
                 else {
                     project.activeAttempts += 1;
-                    const effectiveConcurrency = effectiveHostConcurrency(active.lease, active.runtimeContract);
+                    const effectiveConcurrency = effectiveHostConcurrency(active.lease, active.runtimeContract, active.executionClass);
                     project.safetyClass = conservativeSafetyClass(project.safetyClass, effectiveConcurrency === "host_parallel_safe"
                         ? effectiveConcurrency
-                        : admission.parallelProjectKey && admission.provisionalPromotionFingerprint
-                            ? "host_parallel_candidate"
-                            : "host_serial_only");
+                        : admission.executionClass === "analysis_only"
+                            ? "host_parallel_safe"
+                            : admission.parallelProjectKey && admission.provisionalPromotionFingerprint
+                                ? "host_parallel_candidate"
+                                : "host_serial_only");
                 }
             }
             else {
                 project.reservedAttempts += 1;
-                project.safetyClass = conservativeSafetyClass(project.safetyClass, admission.provisionalPromotionFingerprint ? "host_parallel_candidate" : "host_serial_only");
+                project.safetyClass = conservativeSafetyClass(project.safetyClass, admission.executionClass === "analysis_only"
+                    ? "host_parallel_safe"
+                    : admission.provisionalPromotionFingerprint ? "host_parallel_candidate" : "host_serial_only");
             }
         }
         for (const [dispatchAttemptId, degraded] of this.degraded) {
@@ -179,37 +210,49 @@ export class HostRuntimeLeaseManager {
             }
             return existing.keys;
         }
-        const promotion = await this.promotionStore.load(dispatch.repo.id);
-        const projectKey = projectHostRuntimeSingletonKey(dispatch.repo.id);
-        const keys = promotion ? [] : [projectKey];
+        const executionClass = runtimeExecutionClass(dispatch);
+        const promotion = executionClass === "managed_runtime"
+            ? await this.promotionStore.load(dispatch.repo.id)
+            : null;
+        if (promotion)
+            this.knownPromotions.set(promotion.repoId, promotion);
+        const projectKey = executionClass === "analysis_only"
+            ? projectHostAnalysisKey(dispatch.repo.id)
+            : projectHostRuntimeSingletonKey(dispatch.repo.id);
+        let keys = promotion || executionClass === "analysis_only" ? [] : [projectKey];
         const expiresAt = this.pendingRenewals.get(sandbox.dispatchAttemptId)?.fencingToken === owner.fencingToken
             ? this.pendingRenewals.get(sandbox.dispatchAttemptId).expiresAt
             : dispatch.lease.expiresAt;
         try {
-            if (promotion) {
+            if (promotion || executionClass === "analysis_only") {
                 await this.reserveParallelProject(projectKey, owner, expiresAt, signal);
             }
             else {
-                await this.reserveSingletonKeys(keys, owner, expiresAt, signal);
+                keys = await this.reserveSingletonKeys(keys, owner, expiresAt, signal);
             }
         }
         catch (error) {
             this.clearPendingRenewal(owner);
             throw error;
         }
+        const admittedPromotion = promotion
+            ?? (executionClass === "managed_runtime" && keys.length === 0
+                ? this.knownPromotions.get(dispatch.repo.id) ?? null
+                : null);
         this.admissions.set(sandbox.dispatchAttemptId, {
             repoId: dispatch.repo.id,
             fencingToken: owner.fencingToken,
-            provisionalPromotionFingerprint: promotion?.runtimeContractFingerprint ?? null,
+            executionClass,
+            provisionalPromotionFingerprint: admittedPromotion?.runtimeContractFingerprint ?? null,
             keys,
-            parallelProjectKey: promotion ? projectKey : null,
+            parallelProjectKey: admittedPromotion || executionClass === "analysis_only" ? projectKey : null,
         });
         return keys;
     }
     async reserveSingletonKeys(keys, owner, expiresAt, signal) {
         const owned = keys.every(key => sameSingletonOwner(this.singletonOwners.get(key), owner));
         if (owned)
-            return;
+            return keys;
         const staleFence = [...this.singletonOwners.values()].find(existing => existing.dispatchAttemptId === owner.dispatchAttemptId
             && existing.fencingToken !== owner.fencingToken);
         if (staleFence) {
@@ -220,13 +263,13 @@ export class HostRuntimeLeaseManager {
         throwIfAdmissionExpired(expiresAt);
         if (this.singletonKeysAvailable(keys)) {
             this.assignSingletonKeys(keys, owner);
-            return;
+            return keys;
         }
-        await new Promise((resolve, reject) => {
+        return new Promise((resolve, reject) => {
             const waiter = {
                 owner,
                 keys,
-                resolve: () => resolve(),
+                resolve,
                 reject,
                 signal,
                 expiresAt,
@@ -322,8 +365,9 @@ export class HostRuntimeLeaseManager {
             }
             return {
                 lease: existing.lease,
-                environment: hostRuntimeEnvironment(dispatch.session.id, existing.lease, existing.runtimeContract),
+                environment: hostRuntimeEnvironment(dispatch.session.id, existing.lease, existing.runtimeContract, existing.executionClass),
                 runtimeContract: existing.runtimeContract,
+                executionClass: existing.executionClass,
             };
         }
         const admission = this.admissions.get(sandbox.dispatchAttemptId);
@@ -352,8 +396,8 @@ export class HostRuntimeLeaseManager {
                 runtimeContract = await loadHostRuntimeContract(normalizedWorktreePath);
             }
             catch (error) {
-                if (admission.provisionalPromotionFingerprint) {
-                    await this.promotionStore.invalidate(dispatch.repo.id).catch(() => undefined);
+                if (admission.executionClass === "managed_runtime" && admission.provisionalPromotionFingerprint) {
+                    await this.invalidatePromotion(dispatch.repo.id).catch(() => undefined);
                 }
                 throw error;
             }
@@ -361,11 +405,13 @@ export class HostRuntimeLeaseManager {
                 throw new Error("host_runtime_disabled: project runtime configuration requires Docker execution.");
             }
             const runtimeContractFingerprint = hostRuntimeContractFingerprint(runtimeContract);
-            const promotion = await this.promotionStore.load(dispatch.repo.id);
+            const promotion = admission.executionClass === "managed_runtime"
+                ? await this.promotionStore.load(dispatch.repo.id)
+                : null;
             const promotionMatches = hostRuntimeParallelEligible(runtimeContract)
                 && promotion?.runtimeContractFingerprint === runtimeContractFingerprint;
-            if (admission.keys.length === 0 && !promotionMatches) {
-                await this.promotionStore.invalidate(dispatch.repo.id);
+            if (admission.executionClass === "managed_runtime" && admission.keys.length === 0 && !promotionMatches) {
+                await this.invalidatePromotion(dispatch.repo.id);
                 const projectKeys = hostRuntimeSingletonKeys(dispatch);
                 if (admission.parallelProjectKey) {
                     this.releaseParallelProjectNoDrain(admission.parallelProjectKey, owner);
@@ -374,8 +420,33 @@ export class HostRuntimeLeaseManager {
                 const expiresAt = this.pendingRenewals.get(sandbox.dispatchAttemptId)?.fencingToken === owner.fencingToken
                     ? this.pendingRenewals.get(sandbox.dispatchAttemptId).expiresAt
                     : dispatch.lease.expiresAt;
-                await this.reserveSingletonKeys(projectKeys, owner, expiresAt, signal);
-                admission.keys = projectKeys;
+                admission.keys = await this.reserveSingletonKeys(projectKeys, owner, expiresAt, signal);
+                while (admission.keys.length === 0) {
+                    const promoted = this.knownPromotions.get(dispatch.repo.id);
+                    if (!promoted) {
+                        throw new Error("host_runtime_parallel_promotion_missing: shared admission requires matching promotion evidence.");
+                    }
+                    if (promoted.runtimeContractFingerprint !== runtimeContractFingerprint) {
+                        this.releaseParallelProjectNoDrain(projectKeys[0], owner);
+                        await this.invalidatePromotion(dispatch.repo.id);
+                        admission.keys = await this.reserveSingletonKeys(projectKeys, owner, expiresAt, signal);
+                        continue;
+                    }
+                    admission.parallelProjectKey = projectKeys[0] ?? null;
+                    admission.provisionalPromotionFingerprint = promoted.runtimeContractFingerprint;
+                }
+            }
+            const declaredSingletonKeys = runtimeContract.contract.runtime.singletonResources
+                .map(hostRuntimeDeclaredSingletonKey);
+            const missingSingletonKeys = declaredSingletonKeys
+                .filter(key => !admission.keys.includes(key));
+            if (missingSingletonKeys.length > 0) {
+                const expiresAt = this.pendingRenewals.get(sandbox.dispatchAttemptId)?.fencingToken === owner.fencingToken
+                    ? this.pendingRenewals.get(sandbox.dispatchAttemptId).expiresAt
+                    : dispatch.lease.expiresAt;
+                const reservedSingletonKeys = await this.reserveSingletonKeys(missingSingletonKeys, owner, expiresAt, signal);
+                admission.keys = [...admission.keys, ...reservedSingletonKeys]
+                    .sort((left, right) => left.localeCompare(right));
             }
             const singletonKeys = admission.keys;
             if (!singletonKeys.every(key => sameSingletonOwner(this.singletonOwners.get(key), owner))) {
@@ -391,6 +462,7 @@ export class HostRuntimeLeaseManager {
                 ensurePrivateDirectory(browserProfilePath),
                 ensurePrivateDirectory(testOutputPath),
             ]);
+            await resetGeneratedOutputs(normalizedWorktreePath, testOutputPath);
             let lease = createRuntimeIsolationLease({
                 leaseId: sandbox.executionLeaseId,
                 dispatchAttemptId: sandbox.dispatchAttemptId,
@@ -440,6 +512,7 @@ export class HostRuntimeLeaseManager {
                 attemptRoot,
                 runtimeContract,
                 runtimeContractFingerprint,
+                executionClass: admission.executionClass,
                 parallelPromotionEligible: hostRuntimeParallelEligible(runtimeContract),
                 processSupervisor,
                 adapterCleanups: [],
@@ -449,8 +522,9 @@ export class HostRuntimeLeaseManager {
             this.pendingRenewals.delete(sandbox.dispatchAttemptId);
             return {
                 lease,
-                environment: hostRuntimeEnvironment(dispatch.session.id, lease, runtimeContract),
+                environment: hostRuntimeEnvironment(dispatch.session.id, lease, runtimeContract, admission.executionClass),
                 runtimeContract,
+                executionClass: admission.executionClass,
             };
         }
         catch (error) {
@@ -499,34 +573,49 @@ export class HostRuntimeLeaseManager {
         if (!active || active.lease.fencingToken !== fencingToken || active.lease.state !== "active" || active.releasing) {
             throw new Error("host_runtime_project_unavailable: an active matching host runtime lease is required.");
         }
-        const configuredPort = active.runtimeContract.contract.runtime.ports.find(port => port.launch !== null);
-        if (!configuredPort?.launch) {
+        if (active.executionClass === "analysis_only") {
+            return {
+                lease: active.lease,
+                environment: hostRuntimeEnvironment(active.sessionId, active.lease, active.runtimeContract, active.executionClass),
+                runtimeContract: active.runtimeContract,
+                executionClass: active.executionClass,
+            };
+        }
+        const configuredPorts = active.runtimeContract.contract.runtime.ports.filter((port) => port.launch !== null);
+        if (configuredPorts.length === 0) {
             return {
                 lease: active.lease,
-                environment: hostRuntimeEnvironment(active.sessionId, active.lease, active.runtimeContract),
+                environment: hostRuntimeEnvironment(active.sessionId, active.lease, active.runtimeContract, active.executionClass),
                 runtimeContract: active.runtimeContract,
+                executionClass: active.executionClass,
             };
         }
-        const workingDirectory = await containedWorkingDirectory(active.lease.worktreePath, configuredPort.launch.workingDirectory);
         const owner = hostPortOwner(active.lease);
         const logDirectory = active.lease.resources.paths.find(entry => entry.role === "logs")?.path;
         if (!logDirectory)
             throw new Error("host_runtime_project_invalid: attempt log directory is unavailable.");
         const launcher = new AttemptNodeRuntimeLauncher(active.processSupervisor, owner, logDirectory, this.listenerInspector);
-        const launched = await this.launchNodeRuntime(dispatchAttemptId, fencingToken, configuredPort.name, {
-            command: configuredPort.launch.command,
-            args: configuredPort.launch.args,
-            cwd: workingDirectory,
-            environment: hostRuntimeEnvironment(active.sessionId, active.lease, active.runtimeContract),
-        }, launcher, signal);
-        const promotedLease = await this.promoteVerifiedRuntime(active, launched.runtimeLease);
-        const runtimeEnvironment = hostRuntimeEnvironment(active.sessionId, promotedLease, active.runtimeContract);
+        for (const configuredPort of configuredPorts) {
+            const workingDirectory = await containedWorkingDirectory(active.lease.worktreePath, configuredPort.launch.workingDirectory);
+            await this.launchNodeRuntime(dispatchAttemptId, fencingToken, configuredPort.name, {
+                command: configuredPort.launch.command,
+                args: configuredPort.launch.args,
+                cwd: workingDirectory,
+                environment: {
+                    ...configuredPort.launch.environment,
+                    ...hostRuntimeEnvironment(active.sessionId, active.lease, active.runtimeContract, active.executionClass),
+                },
+            }, launcher, signal);
+        }
+        const promotedLease = await this.promoteVerifiedRuntime(active, active.lease);
+        const runtimeEnvironment = hostRuntimeEnvironment(active.sessionId, promotedLease, active.runtimeContract, active.executionClass);
         const playwright = active.runtimeContract.contract.runtime.playwright;
         if (!playwright) {
             return {
                 lease: promotedLease,
                 environment: runtimeEnvironment,
                 runtimeContract: active.runtimeContract,
+                executionClass: active.executionClass,
             };
         }
         const playwrightPort = promotedLease.resources.ports.find(port => port.name === playwright.baseUrlPort);
@@ -553,8 +642,15 @@ export class HostRuntimeLeaseManager {
             lease: promotedLease,
             environment: { ...runtimeEnvironment, ...preparedPlaywright.environment },
             runtimeContract: active.runtimeContract,
+            executionClass: active.executionClass,
         };
     }
+    providerProcessRunner(dispatchAttemptId, fencingToken) {
+        const active = this.active.get(dispatchAttemptId);
+        if (!active || active.lease.fencingToken !== fencingToken || active.releasing)
+            return null;
+        return new AttemptSupervisedProviderProcessRunner(active.processSupervisor, hostPortOwner(active.lease), this.listenerInspector, active.executionClass === "analysis_only");
+    }
     async promoteVerifiedRuntime(active, runtimeLease) {
         if (!active.parallelPromotionEligible)
             return runtimeLease;
@@ -573,10 +669,11 @@ export class HostRuntimeLeaseManager {
         active.lease = promotedLease;
         try {
             const promotion = await this.promotionStore.observe(active.repoId, active.runtimeContract, runtimeLease.dispatchAttemptId, verifiedPortNames);
+            this.knownPromotions.set(promotion.repoId, promotion);
             this.convertSingletonToParallelProject(projectKey, {
                 dispatchAttemptId: runtimeLease.dispatchAttemptId,
                 fencingToken: runtimeLease.fencingToken,
-            });
+            }, promotion);
             const admission = this.admissions.get(runtimeLease.dispatchAttemptId);
             if (admission?.fencingToken === runtimeLease.fencingToken) {
                 this.admissions.set(runtimeLease.dispatchAttemptId, {
@@ -589,7 +686,7 @@ export class HostRuntimeLeaseManager {
             return promotedLease;
         }
         catch {
-            await this.promotionStore.invalidate(active.repoId).catch(() => undefined);
+            await this.invalidatePromotion(active.repoId).catch(() => undefined);
             active.lease = runtimeLease;
             await this.writeLedger(runtimeLease);
             return runtimeLease;
@@ -831,12 +928,25 @@ export class HostRuntimeLeaseManager {
         }
         this.drainAdmissionWaiters();
     }
-    convertSingletonToParallelProject(key, owner) {
+    convertSingletonToParallelProject(key, owner, promotion) {
         if (!sameSingletonOwner(this.singletonOwners.get(key), owner)) {
             throw new Error("host_runtime_parallel_promotion_stale: matching exclusive project admission is required.");
         }
         this.assignParallelProject(key, owner);
         this.singletonOwners.delete(key);
+        for (let index = 0; index < this.singletonWaiters.length;) {
+            const waiter = this.singletonWaiters[index];
+            if (waiter.keys.length !== 1 || waiter.keys[0] !== key) {
+                index += 1;
+                continue;
+            }
+            this.singletonWaiters.splice(index, 1);
+            clearAdmissionDeadline(waiter);
+            waiter.signal?.removeEventListener("abort", waiter.abort);
+            this.assignParallelProject(key, waiter.owner);
+            this.knownPromotions.set(promotion.repoId, promotion);
+            waiter.resolve([]);
+        }
         this.drainAdmissionWaiters();
     }
     parallelProjectOwned(key, owner) {
@@ -961,11 +1071,91 @@ export class HostRuntimeLeaseManager {
             waiter.resolve();
         }
     }
+    async refreshKnownPromotions() {
+        const promotions = await this.promotionStore.list();
+        this.knownPromotions.clear();
+        for (const promotion of promotions)
+            this.knownPromotions.set(promotion.repoId, promotion);
+    }
+    async invalidatePromotion(repoId) {
+        await this.promotionStore.invalidate(repoId);
+        this.knownPromotions.delete(repoId.trim().toLowerCase());
+    }
     drainAdmissionWaiters() {
         this.drainSingletonWaiters();
         this.drainParallelProjectWaiters();
     }
 }
+class AttemptSupervisedProviderProcessRunner {
+    supervisor;
+    owner;
+    listenerInspector;
+    enforceNoListeners;
+    constructor(supervisor, owner, listenerInspector, enforceNoListeners) {
+        this.supervisor = supervisor;
+        this.owner = owner;
+        this.listenerInspector = listenerInspector;
+        this.enforceNoListeners = enforceNoListeners;
+    }
+    async run(request, handlers = {}, signal) {
+        const child = await this.supervisor.startChildReady("provider", request, handlers, signal, { maxStartAttempts: request.stdin === undefined ? 1 : 3, retryDelayMs: 100 });
+        if (!this.enforceNoListeners)
+            return await child.result;
+        let settled = false;
+        let inspectionFailure;
+        const monitor = (async () => {
+            while (!settled) {
+                try {
+                    const ports = await this.listenerInspector.inspectOwnedLoopbackListeners(child, this.owner);
+                    if (ports.length > 0) {
+                        inspectionFailure = new Error(`host_analysis_listener_violation: analysis-only provider opened undeclared loopback listener(s): ${ports.join(", ")}.`);
+                        await child.stop(this.owner.fencingToken).catch(() => undefined);
+                        return;
+                    }
+                }
+                catch (error) {
+                    inspectionFailure = error;
+                    await child.stop(this.owner.fencingToken).catch(() => undefined);
+                    return;
+                }
+                await waitForAnalysisInspection(250, signal).catch(error => {
+                    if (!settled && !signal?.aborted)
+                        inspectionFailure = error;
+                });
+            }
+        })();
+        try {
+            const result = await child.result;
+            settled = true;
+            await monitor;
+            if (inspectionFailure)
+                throw inspectionFailure;
+            return result;
+        }
+        catch (error) {
+            settled = true;
+            await monitor.catch(() => undefined);
+            if (inspectionFailure)
+                throw inspectionFailure;
+            throw error;
+        }
+    }
+}
+function waitForAnalysisInspection(milliseconds, signal) {
+    if (signal?.aborted)
+        return Promise.reject(cancellationError(signal));
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        }, milliseconds);
+        const abort = () => {
+            clearTimeout(timer);
+            reject(cancellationError(signal));
+        };
+        signal?.addEventListener("abort", abort, { once: true });
+    });
+}
 export class HostRuntimeLeaseCleanupError extends Error {
     lease;
     constructor(lease, cause) {
@@ -980,11 +1170,11 @@ export class HostRuntimeAdmissionExpiredError extends Error {
         this.name = "HostRuntimeAdmissionExpiredError";
     }
 }
-export function hostRuntimeEventResources(lease, runtimeContract) {
+export function hostRuntimeEventResources(lease, runtimeContract, executionClass = "managed_runtime") {
     const requestedHostConcurrency = runtimeContract?.contract.runtime.hostConcurrency ?? "serial";
     const configuredLaunches = runtimeContract?.contract.runtime.ports.filter(port => port.launch !== null) ?? [];
     const verifiedLaunches = configuredLaunches.filter(configured => lease.resources.ports.some(port => port.name === configured.name));
-    const effectiveConcurrency = effectiveHostConcurrency(lease, runtimeContract);
+    const effectiveConcurrency = effectiveHostConcurrency(lease, runtimeContract, executionClass);
     return {
         agentContainer: null,
         sidecarContainers: [],
@@ -994,7 +1184,7 @@ export function hostRuntimeEventResources(lease, runtimeContract) {
         hostConcurrency: effectiveConcurrency,
         requestedHostConcurrency,
         hostParallelPromotion: effectiveConcurrency === "host_parallel_safe"
-            ? "observed_probe_passed"
+            ? executionClass === "analysis_only" ? "analysis_profile_enforced" : "observed_probe_passed"
             : requestedHostConcurrency !== "parallel"
                 ? "not_requested"
                 : configuredLaunches.length > 0 && verifiedLaunches.length === configuredLaunches.length
@@ -1002,6 +1192,7 @@ export function hostRuntimeEventResources(lease, runtimeContract) {
                     : "pending_adapter_probe",
         verifiedRuntimePorts: verifiedLaunches.map(port => port.name),
         runtimeContractSource: runtimeContract?.source ?? "default",
+        executionClass,
         requestedPorts: runtimeContract?.contract.runtime.ports.map(port => port.name) ?? [],
         singletonKeys: lease.resources.singletonKeys,
         processSupervisorId: lease.resources.processSupervisorId,
@@ -1011,7 +1202,7 @@ export function hostRuntimeEventResources(lease, runtimeContract) {
 export function hostRuntimeSingletonKeys(dispatch) {
     return [projectHostRuntimeSingletonKey(dispatch.repo.id)];
 }
-function hostRuntimeEnvironment(sessionId, lease, runtimeContract) {
+function hostRuntimeEnvironment(sessionId, lease, runtimeContract, executionClass) {
     const pathFor = (role) => lease.resources.paths.find(entry => entry.role === role)?.path ?? "";
     const environment = {
         FORGE_SESSION_ID: sessionId,
@@ -1027,10 +1218,13 @@ function hostRuntimeEnvironment(sessionId, lease, runtimeContract) {
         FORGE_CACHE_DIR: pathFor("cache"),
         FORGE_BROWSER_PROFILE_DIR: pathFor("browser_profile"),
         FORGE_TEST_OUTPUT_DIR: pathFor("test_output"),
+        FORGE_ATTEMPT_DATABASE_SCHEMA: `forge_attempt_${uuidHex(lease.dispatchAttemptId, "dispatch attempt")}`,
+        FORGE_ATTEMPT_DATABASE_READINESS_PATH: path.join(pathFor("logs"), "attempt-database-readiness.json"),
         FORGE_PROCESS_SUPERVISOR_ID: lease.resources.processSupervisorId ?? "",
         FORGE_PROCESS_SUPERVISOR_METADATA_PATH: pathFor("process_supervisor_metadata"),
-        FORGE_HOST_CONCURRENCY: effectiveHostConcurrency(lease, runtimeContract),
+        FORGE_HOST_CONCURRENCY: effectiveHostConcurrency(lease, runtimeContract, executionClass),
         FORGE_HOST_CONCURRENCY_REQUESTED: runtimeContract.contract.runtime.hostConcurrency,
+        FORGE_RUNTIME_EXECUTION_CLASS: executionClass,
         FORGE_HOST_RUNTIME_CONTRACT_SOURCE: runtimeContract.source,
         FORGE_SINGLETON_KEYS: lease.resources.singletonKeys.join(","),
         TMPDIR: pathFor("temporary"),
@@ -1057,11 +1251,19 @@ function hostRuntimeEnvironment(sessionId, lease, runtimeContract) {
             }
         }
     }
+    if (environment.FORGE_API_URL)
+        environment.FORGE_E2E_API_URL = environment.FORGE_API_URL;
+    if (environment.FORGE_WEB_URL)
+        environment.FORGE_E2E_WEB_URL = environment.FORGE_WEB_URL;
     if (resolvedBaseUrls.length === 1)
         environment.FORGE_BASE_URL = resolvedBaseUrls[0];
     return environment;
 }
-function effectiveHostConcurrency(lease, runtimeContract) {
+function effectiveHostConcurrency(lease, runtimeContract, executionClass = "managed_runtime") {
+    if (executionClass === "analysis_only") {
+        const analysisSingletonHeld = lease.resources.singletonKeys.length > 0;
+        return analysisSingletonHeld ? "host_serial_only" : "host_parallel_safe";
+    }
     if (!runtimeContract || !hostRuntimeParallelEligible(runtimeContract))
         return "host_serial_only";
     const requiredPorts = configuredLaunchPortNames(runtimeContract);
@@ -1073,6 +1275,18 @@ function effectiveHostConcurrency(lease, runtimeContract) {
 function projectHostRuntimeSingletonKey(repoId) {
     return `project:${repoId.toLowerCase()}:host-runtime`;
 }
+function projectHostAnalysisKey(repoId) {
+    return `project:${repoId.toLowerCase()}:host-analysis`;
+}
+function hostRuntimeDeclaredSingletonKey(resource) {
+    return `runtime:${resource}`;
+}
+function runtimeExecutionClass(dispatch) {
+    return dispatch.runtimeIntent?.executionClass === "analysis_only"
+        && dispatch.runtimeIntent.applicationRuntimeRequired === false
+        ? "analysis_only"
+        : "managed_runtime";
+}
 function capacityProject(projects, repoId) {
     const normalized = repoId.trim().toLowerCase();
     const existing = projects.get(normalized);
@@ -1085,6 +1299,9 @@ function capacityProject(projects, repoId) {
         reservedAttempts: 0,
         waitingAttempts: 0,
         degradedAttempts: 0,
+        runtimeContractFingerprint: null,
+        runtimeContractSource: null,
+        promotedAt: null,
     };
     projects.set(normalized, created);
     return created;
@@ -1104,8 +1321,8 @@ function repoIdFromProjectSingletonKeys(keys) {
 }
 function repoIdFromProjectSingletonKey(key) {
     const prefix = "project:";
-    const suffix = ":host-runtime";
-    return key.startsWith(prefix) && key.endsWith(suffix)
+    const suffix = [":host-runtime", ":host-analysis"].find(candidate => key.endsWith(candidate));
+    return key.startsWith(prefix) && suffix
         ? key.slice(prefix.length, -suffix.length)
         : null;
 }
@@ -1185,13 +1402,17 @@ function validHostProcessSupervisorMetadata(value, lease) {
         && (metadata.rootIdentity == null
             || (typeof metadata.rootIdentity === "string" && metadata.rootIdentity.length <= 256))
         && /^[0-9a-f]{64}$/u.test(metadata.commandDigest)
-        && path.resolve(metadata.worktreePath) === path.resolve(lease.worktreePath)
+        && containedMetadataWorktreePath(lease.worktreePath, metadata.worktreePath)
         && metadata.runtimeLeaseId === lease.executionLeaseId
         && metadata.dispatchAttemptId === lease.dispatchAttemptId
         && metadata.fencingToken === lease.fencingToken
         && Number.isSafeInteger(metadata.bridgePid)
         && metadata.bridgePid > 0;
 }
+function containedMetadataWorktreePath(worktreePath, metadataWorktreePath) {
+    const relative = path.relative(path.resolve(worktreePath), path.resolve(metadataWorktreePath));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
 function transitionHostLeaseForCleanup(lease, state) {
     if (lease.state === state || lease.state === "released")
         return lease;

package/dist/runtime/host-runtime-promotion.d.ts

@@ -3,6 +3,7 @@ export interface HostParallelPromotionRecord {
     readonly schemaVersion: 1;
     readonly repoId: string;
     readonly runtimeContractFingerprint: string;
+    readonly runtimeContractSource?: "project" | "derived";
     readonly observedAt: string;
     readonly observedDispatchAttemptId: string;
     readonly verifiedPortNames: readonly string[];
@@ -12,6 +13,7 @@ export declare class HostParallelPromotionStore {
     private readonly stateRoot;
     constructor(stateRoot: string);
     load(repoId: string): Promise<HostParallelPromotionRecord | null>;
+    list(): Promise<readonly HostParallelPromotionRecord[]>;
     observe(repoId: string, runtimeContract: LoadedHostRuntimeContract, dispatchAttemptId: string, verifiedPortNames: readonly string[]): Promise<HostParallelPromotionRecord>;
     invalidate(repoId: string): Promise<void>;
     private recordPath;